Actionscript Frameworks/ Dev. Software/ Flex/ FlexUnit/ Open-source

FlexUnit, necessário e prático para toda aplicação

Poucos desenvolvedores que conheço no Brasil que trabalham com Flex ou com desenvolvimento de sistemas usam testes unitários, o que é pouco para o número de desenvolvedores já existentes ou que vinheram de linguagens bastante notórias em nossa área.
O que eu vejo é o mal hábito de salvar e testar na base do click, é válida o teste mais horas vindo e indo vai causar algum problema que toma muito seu tempo. No qual tira todo o propósito de se criar uma aplicação em Flex que é justamente ser produtivo.

Ao contrário do que você pensa, testes unitários não cria regras de testes à serem executadas, apenas criar especificações que você define para aprovar o que seu código tem a lhe dizer sobre tais métodos disponíveis.

FlexUnit é um projeto open-source, escrito em actionscript 3.0 e que pode te ajudar nesta tarefa chata porém necessária, Você pode criar até seus métodos próprios para testar, mais o FlexUnit é bem completo neste quesito reduzindo assim seu tempo nesse caso de criar do zero.

Como então usar o FlexUnit?

Primeiro faça o download do pacote aqui no site abaixo.
http://opensource.adobe.com/wiki/display/flexunit/Downloads

Depois de baixar, descompacte os arquevos em um diretório seu de preferência. Feito isso, arraste o arquevo FlexUnit.swc para dentro da pasta de seu projeto criado ou existente dentro do Flex Builder, veja como ficou o meu na imagem abaixo:

Pronto seu projeto vai estar apto a criar testes unitários ja que a biblioteca necessária já está adicionada, porém trabalhar com testes unitários requer um pouco mais que só adicionar a biblioteca ao seu projeto. Outro passo que você deve testar é o uso da interface que faz o controle. Para isso adicione em sua aplicação Flex o seguinte código fonte.

1
2
3
4
< ?xml version="1.0" encoding="utf-8"?>
<mx :Application xmlns:mx="http://www.adobe.com/2006/mxml" layout="absolute" xmlns:flexui="flexunit.flexui.*">
<flexui :TestRunnerBase id="testeUnitario" width="100%" height="100%"/>
</mx>

Veja que o código acima gera para você a interface de controle do FlexUnit

Que nada mais é que a repesentação gráfica do controle para testes unitários, onde você ver os resultados que foram colhidos em seu teste unitário.
Depois disso, você precisa conhecer um pouco como funciona o FlexUnit, e como é todo esse processo de testes, para facilitar o seu entendimento veja as definições de cada fase do FlexUnit.

assertions – É o resultado esperado pelo seu teste. Por exemplo se você falar que em São Paulo tem sempre poluição o seu código tem que dizer que São Paulo é poluída. Se em seu teste ele não dê a resposta esperada setada pelo assertion, é sinal que você tem que mudar em sua classe e ver onde o erro está associado.

test fixture – Para cada deste poderá haver a necessidade de dependência de criar objetos, propriedades ou até processos para realizar o teste. test fixture funciona justamente nesse aspecto devido fornecer no FlexUnit dois métodos necesários para isso o setUp() e o tearDown(), que exclui a possibilidade de testar duas ou mais instâncias do teste sem a necessidade de se criar redundancia do código, ja que qualquer propriedade pode ser usada ao topo da classe.

test case – Uma pequena parte do teste unitário, test case ou caso de teste, checa apenas uma especificação de dados a serem inseridos no teste. No caso do test case para adiciona-la ao TestSuite, você tem que estender a classe TestCase para ser adicionado ao JUnit. Por regra de padrões de uso do JUnit é interessante que toda classe que for estendida do TestCase que sempre venha com um sufixo exemplo : CalculadoraTest extends TestCase; E dentro de classe cada método usado para testar suas regras de especificações aconselha-se também que use o prefixo test antes do método em si, exemplo: testSoma();

test suite Não tem aquile ditado que comentam: “Quanto mais melhor?!”, é o caso do test suite, quanto mais testes forem acumulados mais fácil será de administrá-los se você agrupa-los.
Onde o próprio test suite pode agrupar outros test suites, testes individuais e até mesmo qual teste pode ser rodado na mesma sessão.

test runner – Lembra do componente adicionado para mostrar seus testes sendo executados? É o tal sujeito test runner, ele apenas mostra o que foi executado como teste, no FlexUnit o teste começa com o método startTest();

Para que o FlexUnit consiga enxergar tudo isso, você precisa instanciá-lo e fazer com que ele passe a receber todos os testes que está sendo executado em sua aplicação.

Começando assim, adicione mais esse código abaixo dentro de sua aplicação principal do Flex:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
< ?xml version="1.0" encoding="utf-8"?>
<mx :Application xmlns:mx="http://www.adobe.com/2006/mxml" layout="absolute" xmlns:flexui="flexunit.flexui.*">
 
</mx><mx :Script>
	< ![CDATA[
 
		    import flexunit.framework.TestSuite;
 
            private function criarTesteUnitario():TestSuite
            {
                var testeUni:TestSuite = new TestSuite();
                return testeUni;
            }
 
	]]>
</mx>
 
 
<flexui :TestRunnerBase id="testeUnitario" width="100%" height="100%"/>

Eu criei uma função que vai instanciar o TestSuite onde este objeto criado pode ser adicionado os testes necessários pelo TestCase como mostra no código à seguir.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
< ?xml version="1.0" encoding="utf-8"?>
<mx :Application applicationComplete="iniciarTestes()" xmlns:mx="http://www.adobe.com/2006/mxml" layout="absolute" xmlns:flexui="flexunit.flexui.*">
</mx><mx :Script>
	< ![CDATA[
 
            import flexunit.framework.TestSuite;
 
            private function criarTesteUnitario():TestSuite
            {
                var testeUni:TestSuite = new TestSuite();
                return testeUni;
            }
            private function iniciarTestes():void{
            	testeUnitario.test = criarTesteUnitario();
            	testeUnitario.startTest();
            }
 
	]]>
</mx>
 
 
<flexui :TestRunnerBase id="testeUnitario" width="100%" height="100%"/>

Veja que agora eu associei o meu componente com a instância testeUnitario com a função que vai guardar todos os testes que eu fizer pelo TestSuite, o disparo que fiz foi pelo evento applicationComplete para ter certeza que os testes só iniciará quando toda a minha aplicação e suas respectivas classes tiverem despejadas na memória. Lembrando que existem casos que testes unitários são necessários serem feitos no processo de inicialização da aplicação, o que isso é assunto para outros posts.
O resultado do código abaixo é que o FlexUnit já está começando a executar os testes, porém como não há nenhum teste unitário feito, eu preciso adicionar algum tipo de testeCase para ele.

Adicionando testes:

Antes de adicionar classes de testes ao FlexUnit, para facilitar a organização e não acabar estragando tudo e misturando tudo em um só diretório, você cria ai como fiz aqui no meu, uma pasta “test”.

Lembra ainda to TestCase que é a classe necessária para adicionar as especificações para o nosso teste? Vamos usar ela, mais antes de começar com ela, vou criar uma classe simples com soma,divisão, multiplicação,subtração ao meu projeto para que ele teste,afinal até então não criei nada para ele testar. Detalhe que essa classe não fica na pasta test, não confunda! Ela fica no src mesmo, na pasta test só as futuras classes de testes.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
package com.igorcosta
{
	public class Matematica
	{
		public function Matematica()
		{
			super();
		}
 
		private var resultado:Number = 0;
		public function Somar(numA:Number,numB:Number):Number{
			return resultado = numA+numB;
		}
		public function Dividir(numA:Number,numB:Number):Number{
			return  resultado = numA/numB;
		}
		public  function Subtrair(numA:Number,numB:Number):Number{
			return  resultado = numA-numB;
		}
		public function Multiplicar(numA:Number,numB:Number):Number{
			return  resultado = numA*numB;
		}
		public function getResultado():Number{
			return resultado;
		}
	}
}

Com a classe matemática pronta, começe a criar a outra classe teste nesse caso chamo ela de MatematicaTest, lembra do sufixo?!

1
2
3
4
5
6
7
8
9
10
11
12
13
package test
{
	import flexunit.framework.TestCase;
 
	public class MatematicaTest extends TestCase
	{
		public function MatematicaTest(methodName:String=null)
		{
			super(methodName);
		}
 
	}
}

A classe faz parte do pacote test e estende a classe TestCase necessária para adicionar os testes.
A partir dai ja estamos com 75% pronto para rodar o primeiro teste, basta agora eu montar as especificações ao a minha classe e depois adicionar ao TestSuite e executar no TestRunner.

Como fazer?
Veja a classe final do meu teste, como quero aqui é apenas um exemplo me limitei a mostrar 2 métodos o somar e subtrair, veja como ficou a minha classe.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
package test
{
	import com.igorcosta.Matematica;
 
	import flexunit.framework.TestCase;
 
	public class MatematicaTest extends TestCase
	{
		public function MatematicaTest(methodName:String=null)
		{
			super(methodName);
		}
 
		public function testSomar():void {
			var somando:Matematica = new Matematica();
			somando.Somar(40,40);
			assertTrue("Depois da soma de 40 a mais 40 o valor precisa ser 80",somando.getResultado() == 80);
		}
		public function testSubtrair():void{
			var subtrai:Matematica = new Matematica();
			subtrai.Subtrair(10,2);
			assertTrue("Depois da subtracao de 10 menos 2 o valor precisa ser 8",subtrai.getResultado() == 8);
		}
	}
}

Para finalizar, volto ao meu aplicativo principal e adiciono lá nas minhas funções o MatematicaTest ao TestSuite para rodar pelo testRunner.

Resultado final do meu aplicativo principal.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
< ?xml version="1.0" encoding="utf-8"?>
<mx :Application applicationComplete="iniciarTestes()" xmlns:mx="http://www.adobe.com/2006/mxml" layout="absolute" xmlns:flexui="flexunit.flexui.*">
 
</mx><mx :Script>
	< ![CDATA[
		import test.MatematicaTest;
 
		    import flexunit.framework.TestSuite;
 
            private function criarTesteUnitario():TestSuite
            {
                var testeUni:TestSuite = new TestSuite();
                testeUni.addTestSuite(MatematicaTest);
                return testeUni;
            }
            private function iniciarTestes():void{
            	testeUnitario.test = criarTesteUnitario();
            	testeUnitario.startTest();
            }
	]]>
</mx>
 
 
<flexui :TestRunnerBase id="testeUnitario" width="100%" height="100%"/>

E ao clicar em Run no Flex Builder veja o resultado final dos meus testes na imagem abaixo.

Para onde ir depois de ler esse exemplo, tentei reunir aqui uma coleção de links para te ajudar no seus estudos futuros.

JUnit – Foi usado seu modelo no FlexUnit

Visão geral de como usar o FlexUnit – em inglês

Rodando FlexUnit via InsideRIA – em inglês

Definição de UnitTest na Wikipedia – em inglês

FlexUnit com Ant – em inglês ( Esse em particular é o que uso, muito prático).

One thought on “FlexUnit, necessário e prático para toda aplicação

Comments are closed.