Testes Unitários em Java ME com JMUnit

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.

Nesse post farei 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.

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.

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.

Agora vamos fazer mais um teste para nosso método. Vá na classe TemperatureConversionTest e adicione o sequinte método:

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.

Olhando o resultado dos testes percebemos que um deles passou e outro falhou. Vamos refatorar o método responsável pela conversão das temperaturas na classe TemperatureConversion colando a fórmula para conversão de Celsius para Kelvin, que é K = ºC + 273. Modifique o método para:

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.

Opa! Barrinha vermelha de novo. Mas o que será que está errado?

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.

Espero que todos tenham gostado. Sugestões e críticas são bem-vindas. Até a próxima!

Referências:

Brunno Silva Weblog

JMUnit – JUnit for Java ME

Testing Wireless Java Applications

JUnit Testing Using Java ME JUnit Frameworks

Introdução ao Desenvolvimento Orientado a Testes (TDD) – Conding Dojo Floripa