Nesse post, retirado do blog do Rafael Vianna, faremos uma pequena introdução aos tipos de teste, dando maior importância aos testes unitários e como eles podem ser utilizados em Java ME com framework JMUnit e a metodologia Test-Driven Development.
Testes automatizados são algo fundamental no desenvolvimento de software orientado a objetos. Eles permitem uma melhor evolução do software agregando confiança e qualidade ao produto final. No mundo Java SE e Java EE existem muitas ferramentas de testes. Quando olhamos para Java ME o número de ferramentas torna-se menor, devido tanto aos requisitos das aplicações quanto as restrições impostas pela própria API Java ME.
Diferentes tipos de testes em aplicações Java ME
Existem vários tipos de testes e eles variam de acordo com a aplicação e com os requisitos desejados pelo cliente. Em aplicações Java ME os principais tipos de teste são:
Testes de Usabilidade: tem foco na navegação entre as telas da aplicação e na maneira que os componentes visuais comunicam-se com o usuário.
Teste de performance e trafego na rede: testa se a aplicação funciona bem em redes que apresentam condições extremas. Aplicativos móveis devem funcionar de maneira satisfatória mesmo em redes muito congestionadas.
Testes do lado servidor: muitos aplicativos Java ME comunicação com servidores remotos. Para tais aplicativos testar as interfaces entre a aplicação que roda no dispositivo móvel e o servidor remoto é muito importante.
Testes unitários automatizados: estes é um dos mais importantes testes, seja em aplicativos móveis, Web ou Desktop. Ele feito durante o desenvolvimento do aplicativo, juntamente com o código-fonte. Geralmente esses testes são criados com algum framework da família xUnit (jUnit, nUnit, etc).
TDD
Test-Driven Development é uma maneira diferente de escrever software. Nela você primeiro escreve o teste e depois escreve o código a ser testado. O TDD está conseguindo cada vez mais adeptos graças a sua simplicidade e alto grau de qualidade do código ao durante todo o processo de desenvolvimento.
Algumas vantagens dessa abordagem são:
* Simplicidade
* Aumento da confiança no código
* Ajuda na documentação
* Falicita refatorações
O processo de criação no TDD é simples:
1. Escreva um teste que falhe
2. Faça o teste passar o mais rápido possível
3. Refatore
4. Faça o teste passar
5. Refatore seus testes
6. Faça os passos 1 a 5 para cada novo teste
7. Repita todos os passos para cada novo método adicionado
Framworks para Testes Unitários
Para escrever testes unitários existem alguns frameworks, sendo o mais famosos deles o JUnit. Infelizmente o JUnit só pode ser utilizado em ambientes Java SE e Java EE, devido principalmente a algo que ele usa e é totalmente inexistente da API Java ME: reflexão. Isso ficou mais complicado depois do lançamento da versão 4 do JUnit, que agora também tem suporte a Annotations. Mesmo com essas barreiras, existem frameworks para testes unitários em Java ME, sendo os principais o JMUnit e o J2MEUnit.Testes automatizados são algo fundamental no desenvolvimento de software orientado a objetos. Eles permitem uma melhor evolução do software agregando confiança e qualidade ao produto final. No mundo Java SE e Java EE existem muitas ferramentas de testes. Quando olhamos para Java ME o número de ferramentas torna-se menor, devido tanto aos requisitos das aplicações quanto as restrições impostas pela própria API Java ME.
Diferentes tipos de testes em aplicações Java ME
Existem vários tipos de testes e eles variam de acordo com a aplicação e com os requisitos desejados pelo cliente. Em aplicações Java ME os principais tipos de teste são:
Testes de Usabilidade: tem foco na navegação entre as telas da aplicação e na maneira que os componentes visuais comunicam-se com o usuário.
Teste de performance e trafego na rede: testa se a aplicação funciona bem em redes que apresentam condições extremas. Aplicativos móveis devem funcionar de maneira satisfatória mesmo em redes muito congestionadas.
Testes do lado servidor: muitos aplicativos Java ME comunicação com servidores remotos. Para tais aplicativos testar as interfaces entre a aplicação que roda no dispositivo móvel e o servidor remoto é muito importante.
Testes unitários automatizados: estes é um dos mais importantes testes, seja em aplicativos móveis, Web ou Desktop. Ele feito durante o desenvolvimento do aplicativo, juntamente com o código-fonte. Geralmente esses testes são criados com algum framework da família xUnit (jUnit, nUnit, etc).
TDD
Test-Driven Development é uma maneira diferente de escrever software. Nela você primeiro escreve o teste e depois escreve o código a ser testado. O TDD está conseguindo cada vez mais adeptos graças a sua simplicidade e alto grau de qualidade do código ao durante todo o processo de desenvolvimento.
Algumas vantagens dessa abordagem são:
* Simplicidade
* Aumento da confiança no código
* Ajuda na documentação
* Falicita refatorações
O processo de criação no TDD é simples:
1. Escreva um teste que falhe
2. Faça o teste passar o mais rápido possível
3. Refatore
4. Faça o teste passar
5. Refatore seus testes
6. Faça os passos 1 a 5 para cada novo teste
7. Repita todos os passos para cada novo método adicionado
Framworks para Testes Unitários
O framework JMUnit
O JMUnit é um framework nos mesmos moldes do JUnit voltada para Java ME. Possui uma versão para configuração CLCD (1.0 e 1.1), é open-source e foi criado pelo brasileiro Bruno Silva.
JMUnit na prática
Chegou a hora de utilizar o JMUnit. Crie um novo MIDlet Project no Eclipse com o nome Java ME unit testes. Dentro da pasta src crie dois pacotes: model e jmunit.tests. A sua estrutura de diretórios deve ficar parecida com a da figura abaixo:
Vamos fazer algo bem simples somente para demonstração: uma classe que fará a conversão de temperatura de Celsius para Kelvin. Lembre-se que iremos utilizar TDD, então vamos escrever os testes primeiro.
Escrevendo os Testes
O JMUnit possui dois conceitos principais:
Test Case: classe onde os casos de testes são escritos.
Test Suite: classe onde os Test Cases são executados.
A primeira coisa que faremos é criar um Test Case para nossa classe de conversão. Para fazer isso siga os passos abaixo:
1 - Clique em o botão direito sobre o pacote jmunit.tests
2 - Selecione New - JMUnit Test Case
3 - Caso uma mensagem de alerta apareça na parte inferior do Wizard, clique onde diz Click here. Coloque o nome da classe de ConversionTest. Clique em Finish.
A classe gerada apresenta um construtor e um método:
public ConversionTest()
{
super(0, "TemperatureConversionTest");
}
public void test(int testNumber) throws Throwable
{
switch (testNumber)
{
}
}
O construtor possui dois parâmetros: o número de testes existentes no Test Case e o nome do Test Case. No método test nos passamos o número de testes que serão executados que servirá para o switch.Agora vamos adicionar nossos testes. Irei seguir o padrão do JUnit onde cada método não terá retorno (void) e começa com o nome test seguido do nome do método que irá ser testado. O primeiro test será esse:
public void testcelsiusToKelvin() throws AssertionFailedException
{
float result = TemperatureConversion.celsiusToKelvin(); // apresenta erro.
assertEquals(0, result);
}
Para o teste acima funcionar você deve alterar o construtor da classe e o método test. Eles ficarão assim:public ConversionTest()
{
// Passe o número de testes no construtor, nesse caso o número 1
super(1, "ConversionTest");
}
public void test(int testNumber) throws Throwable
{
switch (testNumber)
{
// Também modificamos o "case". Lembre-se que o “case” em Java começa em 0.
case 0: testcelsiusToKelvin(); break;
default: break;
}
}
Para rodar o teste é necessário criar um Test Suite. É bem simples criar um:1 – Clique com o botão direito em cima da pacote “jmunit.tests”.
2 – Vá em New - JMUnit Test Suite.
3 – No Wizard que irá aparecer apenas clique em Finish
Agora siga os passos abaixo para rodar o teste:
1 – Clique com o botão direito em cima do Test Suite AllTestSuite.
2 – Vá em Run As - Emulated Java ME MIDlet.
3 – Surgirá uma janela de alerta do Eclipse. Clique no botão Proceed.
Rode o teste clicando em Test.
Opa! O testes falhou. Olhando o resultado do teste pode-se observar que a classe TemperatureConversion não existe. Realmente ela não existe ainda já estamos usando TDD. Escrevemos primeiro o teste e depois o código que irá ser testado, lembre-se disso.
Crie a classe:
1 – Utilize o Quick Fix do eclipse (Ctrl+1 ou clique no ‘x’ no começo da linha) e escolha a primeira opção: Create Class TemperatureConversion.
2 – Quando o Wizard aparacer, escolha o pacote model. Para isso clique no botão Browser, escolha o pacote model.
3 – Clique em Finish.
4 – Faça o mesmo processo para criar o método celsiusToKevin na classe TemperatureConversion . Não mude o conteúdo do método gerado.
Rodando o teste novamente ele irá passar. Isso é visto com a barrinha verde apresentada no MIDlet Emulator.
public void testcelsiusToKelvin(float c, float k) throws AssertionFailedException
{
k = TemperatureConversion.celsiusToKelvin(c);
assertEquals(298, k);
}
Não esqueça de mudar o construtor e o método test da classe:public TemperatureConversionTest()
{
super(2, "TemperatureConversionTest");
}
public void test(int testNumber) throws Throwable
{
switch (testNumber)
{
case 0: testcelsiusToKelvin();break;
case 1: testcelsiusToKelvin(25, 298);
default: break;
}
}
Rode a classe AllTestSuite novamente. Perceba que agora temos dois testes. Execute os testes.
public static float celsiusToKelvin(float celsius)
{
float kelvin = celsius + 273;
return kelvin;
}
Parece tudo OK agora, não é? Só para garantir, rode os testes novamente.
Vá na nossa classe de testes. Você esqueceu de refatorar o nosso primeiro método de testes. Modifique-o para:
public void testcelsiusToKelvin() throws AssertionFailedException
{
// Agora é necessário passar um parâmatro para o método que nesse caso é 0 (zero).
float result = TemperatureConversion.celsiusToKelvin(0);
assertEquals(273, result);
}
Rode os testes e barrinha verde novamente aparecerá.
Conclusão
Testes unitários são algo de extrema importância no desenvolvimento de software. Como podemos ver, escrever testes unitários é algo bem simples e não há desculpas para não fazê-lo, seja em que ambiente for. No mundo Java ME existem outros frameworks para testes unitários, mas prefiro o JMUnit por sua simplicidade, por seguir o padrão xUnit e também por já estar integrado ao Eclipse Pulsar.