Pessoal

O que está acontecendo com os designers?

Bom, eu chutei o pau da barraca agora a pouco no twitter, mais por um motivo. “O que está acontecendo com os designers?”.

Se você tiver um tempinho vai ver o meu motivo.

A cerca de 45 dias eu estou tentando colocar no ar um projeto meu que tem à ver com a igorcosta.com que vai beneficiar várias pessoas. Começo a fazer as especificações e o briefing do projeto, feito isso vou atrás de um designer.

Bato na porta dos mais famosos e menos famosos designers, em fim todos que eu tenho aqui a URL do portifolio.

Alguns respondem, outros não deram sinal de vida e 1 ignorou o projeto devido a falta de tempo.

Os que responderam sempre dizem: “Olha vai demorar 10 dias para terminar o design do site”. Alguns falam mais que isso.

Porém o que me deixou frustrado foi o fato de que os que se comprometeram de enviar uma proposta já não responderam mais, são mais de 3 semanas e nada de enviarem uma proposta para o projeto iniciar novamente.

Nem pedi a ajuda do pessoal que é meu parceiro a Orange Design por que já temos alguns projetos rolando e todos os recursos já estão alocados.

Então eu afirmo: Onde está os designers de bom portifólio que são cumpridores de seu trabalho e que queiram trabalhar de verdade? Onde vocês estão, por que ao meu ver o erro foi meu em não achar o designer certo.

Fica complicado trabalhar assim, precisamos do serviço do designer mais não achamos nenhum que queria trabalhar, que tenha tempo livre, que se dedique e que queira trabalhar full-time conosco.

Ajuda né pessoal, por que isso dá uma raiva.

Entre em contato comigo jobs@igorcosta.com

AbsolutoBrasil/ Actionscript Frameworks/ Comunidade

Chamada de colaboradores para o AbsolutoBrasil

Estou precisando de colaboradores para o projeto AbsolutoBrasil.

Semana passada eu retomei o projeto AbsolutoBrasil que visa fortalecer o desenvolvimento de aplicações RIA em Flex de forma fácil.

Nesta nova versão existe uma série de aproveitamentos e novidades, entre elas um MVC. Sendo assim fácil a criação de Model, View e Controller para sua aplicação, muitos componentes de controle, várias classes utilitarias, integração com outras API, Dentre outras idéias.

É um projeto inteiramente Open-source, que você pode encontrar aqui.

Eu não sei se foi por falta de conhecimento dos desenvolvedores ou se não atingiu a forma esperada como eu achei que fosse atingir, mais estou em busca de colaboradores para o projeto.

Se você tem um tempo livre, 2 horas por dia e quer entrar para o time do AbsolutoBrasil, entre em contato.

Estamos precisando de desenvolvedores, novas idéias, snippets,beta testes, implementações. Tudo será bem vindo na medida do possível.

Entre em contato direto comigo. igorcosta@igorcosta.com

BlazeDS/ Flex/ Flex e Java/ Java

Estensões para o BlazeDS

Quando uma solução vira open-source e tendo uma comunidade gigantesca ao redor do mundo que pode colocar as mãos no código fonte, vira um espetáculo de experiência.

É o caso do BlazeDS, pouco mais de 6 meses de vida o produto já tem as seguintes soluções como estesão de acesso para melhorar seu uso. Vale a pena visitar cada projeto desse e incrementar seu BlazeDS.

Full Lazy Load para BlazeDS – http://code.google.com/p/dphibernate/
SpringFactory para logins seguros – http://code.google.com/p/blazeds-addons
Data Services Adapters e Factories – http://code.google.com/p/dsadapters/
Flex Mail Adapter – Envie e-mails direto do seu BlazeDS fácilmente – http://code.google.com/p/flexserverlib/
Como trabalhar com BlazeDS, Spring e Flex – http://code.google.com/p/maven-blazeds-spring-archetype/

Flex/ Flex e Java/ Java

JSF-Flex – Crie aplicações Flex usando JSF

O projeto JSF-Flex usa JSF para criar aplicações Flex.

O que a biblioteca faz de fato? Ela rendeniza o código escrito em JSF e gera componentes Flex e a interface da aplicação, gerando também swc que vão depender para o aplicativo, componentes do Flex e o arquevo .swf final para ser inserido na aplicação JSF ao invés do próprio HTML.

Foi criado por um engenheiro da IBM, embora seja bem novato neste quesito o JSF-Flex promete, ja que ele tem algumas coisas que vale muito apena investigar para aquiles que estão pensando em usar JSF para criar aplicações corporativas, só que com HTML.

A vantagem é que você não sai do seu ambiente JSF e de quebra leva uma interface intuitiva do Flex em sua aplicação.

Visite o projeto no Google Code aqui, e saiba mais neste artigo da Enterprise Java Community.

Eventos/ Java/ JustJava

Just Java 2008 – segundo dia

Ontem, eu esqueci de tirar algumas fotos e fazer um breve vídeo sobre o evento. Hoje segundo dia e tem muita palestra boa. Embora eu esteja em uma que o Coreano deixa metade do público com sono, mais o conteúdo é bom. Fala sobre o servidor GlassFish, com suporte nativo a lazyload e lazymodule.

Segue abaixo algumas fotos tiradas hoje no evento e um video.



Hoje a noite os videos ficam pronto.

As palestras agora no auditório principal é de dois engenheiros da Microsoft falando sobre JNBridge para Java e .Net com o subtitulo interoperabilidade entre as duas interfaces da linguagem.

Eventos/ Pessoal

Amanhã no Just Java 2008

Amigo leitor, amanhã começará o primeiro dos grandes eventos da comunidade Java no Brasil, já que setembro é o mês do Java em terras tupiniquens.

Amanhã começa o evento. Se por algum motivo você queira conversar comigo, sinta-se à vontade e vamos bater um papo e trocar figurinhas.

Nos vemos lá.

Actionscript/ Actionscript Frameworks/ AMFPHP/ Flex/ Open-source

Gerar PDF de sua aplicação Flex para desenvolvedores PHP

Gerar PDF de sua aplicação Flex é super simples, existem hoje no mercado algumas soluções open-source para se gerar PDF à partir de sua aplicação Flex, a biblioteca que vou usar neste exemplo é a APDF uma biblioteca gratuita e que serve apenas para desenvolvedores que usam o php como linguagem de server-side.
Claro que você pode por outra vez usar outra linguagem de server-side para gerar o documento em PDF para asp por exemplo ou até para Java, mais ai já é por sua conta e risco.

Limitações do aPDF:

  • Não suporta PNG
  • Não suporta rawData
  • Não suporta embed de fontes
  • Não suporta manipulação final do encoder do Acrobat Reader

Ingredientes usados:

aPDF
Baixe a versão que usa o as3corelib, para fazer o encoder de imagem.

Primeiro passo que vou fazer é adicionar conteúdo ao meu aplicativo, para isso copie o código abaixo e coloque em seu aplicativo.

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
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
< ?xml version="1.0" encoding="utf-8"?>
<mx :Application backgroundColor="#f4f4f4" xmlns:mx="http://www.adobe.com/2006/mxml" layout="absolute">
 
</mx><mx :XML id="lista" xmlns="">
	<root>
			<pedidos>
					<pedido>
					     <produto>
					     	<nome>Escova dentária</nome>
					     	<valor>400</valor>
					     </produto>
					     <produto>
					     	<nome>Creme Dental</nome>
					     	<valor>100</valor>
					     </produto>
					     <produto>
					     	<nome>Fio Dental</nome>
					     	<valor>50</valor>
					     </produto>
					     <produto>
					    	<nome>Sabonete</nome>
					    	<valor>10</valor>
					     </produto>
					</pedido>
			</pedidos>
	</root>
</mx>
 
	<mx :VDividedBox height="100%" width="100%">
	</mx><mx :VBox width="100%" height="50%">
		</mx><mx :ColumnChart dataProvider="{lista.pedidos.pedido.produto}" id="graficocoluna" width="100%" height="100%">
 
		</mx><mx :horizontalAxis>
					<mx :CategoryAxis dataProvider="{lista.pedidos.pedido.produto}" categoryField="nome"/>
			</mx><mx :series>
			</mx><mx :ColumnSeries displayName="Pedidos" yField="valor">
				</mx><mx :fill>
						<mx :SolidColor color="0x7BCE2A"/>
		<mx :Legend dataProvider="{graficocoluna}"/>
		</mx><mx :VBox width="100%" height="50%">
		</mx><mx :DataGrid dataProvider="{graficocoluna.dataProvider}" width="100%" height="100%">
			</mx><mx :columns>
				<mx :DataGridColumn headerText="Produto" dataField="nome"/>
				<mx :DataGridColumn headerText="Preço" dataField="valor"/>
			</mx>
 
		<mx :HBox width="100%" horizontalAlign="center" height="45" verticalAlign="middle">
			<mx :Button label="Gerar PDF"/>
		</mx>

Com o esqueleto pronto, é hora de programar o o aPDF para adicionar a imagem do gráfico e os resultados do datagrid para o documento pdf.

Primeiro passo é você baixar tanto a biblioteca aPDF e a as3corelib e coloca-las dentro da pasta src, lembre-se que ambas compartilham o mesmo diretório “com”, como diretório principal para o pacote de classes, então só jogar o as3corelib dentro do “com” e o apdf tbm, veja aqui como ficou o meu.

Caso você queira, só baixar aqui um arquevo zip que fiz para ambos, basta só arrastar o conteúdo desse zip para seu diretório src do projeto. Clique aqui para baixar o zip.

Outra coisa que fiz é colocar o diretório php que vem junto com o aPDF dentro do meu servidor XAMPP, na pasta htdocs.

Adicionando objetos ao meu arquevo PDF.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
<mx :Script>
	< ![CDATA[
		import com.candymandesign.pdf.objects.APDFormat;
		import com.candymandesign.pdf.APDF;
 
				private var _pdfObject:APDF;
 
				public function gerarPDF():void{
 
						_pdfObject = new APDF();
						_pdfObject.addPage();
						_pdfObject.setPageSize(APDFormat.PAGE_SIZE_A4);
						_pdfObject.currentPage.addImage(graficocoluna,60,50,50);
						_pdfObject.export("http://localhost/apdf/apdf.php");
 
				}
	]]>
</mx>

Gerar a página em pdf é simples, veja que do código acima eu criei um objeto _pdfObject que deriva da instância da classe APDF, depois adiciono ai uma página com o método addPage().
Depois que executo o método addPage(), vou setar o formato desta minha página usando o método setPageSize(), no caso acima uso uma classe auxiliar que é a APDFFormat para gerar em A4; Logo eu pego a página atual ou seja currentPage e adiciono uma imagem usando o método addImage(), este método vem com parametros onde seto o primeiro que é o alvo ou seja uma imagem que venha da classe DisplayObject e depois seto a qualidade desta imagem que vai de zero até 100, o padrão dela é 60, e depois os valores de x, y para posicionar na página e larguar e altura da imagem.
No final de todo o processo de montar a página, etc, eu executo o método export, que aponta para meu arquevo apdf.php que recebe os valores e gera o pdf final.

O resultado do código final é o seguinte.

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
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
< ?xml version="1.0" encoding="utf-8"?>
<mx :Application backgroundColor="#f4f4f4" xmlns:mx="http://www.adobe.com/2006/mxml" layout="absolute">
 
 
</mx><mx :Script>
	< ![CDATA[
		import com.candymandesign.pdf.objects.APDFormat;
		import com.candymandesign.pdf.APDF;
 
				private var _pdfObject:APDF;
 
				public function gerarPDF():void{
 
						_pdfObject = new APDF();
						_pdfObject.addPage();
						_pdfObject.setPageSize(APDFormat.PAGE_SIZE_A4);
						_pdfObject.currentPage.addImage(graficocoluna,60,50,50);
						_pdfObject.export("http://localhost/apdf/apdf.php");
 
				}
	]]>
</mx>
 
<mx :XML id="lista" xmlns="">
	<root>
			<pedidos>
					<pedido>
					     <produto>
					     	<nome>Escova dentária</nome>
					     	<valor>400</valor>
					     </produto>
					     <produto>
					     	<nome>Creme Dental</nome>
					     	<valor>100</valor>
					     </produto>
					     <produto>
					     	<nome>Fio Dental</nome>
					     	<valor>50</valor>
					     </produto>
					     <produto>
					    	<nome>Sabonete</nome>
					    	<valor>10</valor>
					     </produto>
					</pedido>
			</pedidos>
	</root>
</mx>
 
	<mx :VDividedBox height="100%" width="100%">
	</mx><mx :VBox width="100%" height="50%">
		</mx><mx :ColumnChart dataProvider="{lista.pedidos.pedido.produto}" id="graficocoluna" width="100%" height="100%">
 
			</mx><mx :horizontalAxis>
					<mx :CategoryAxis dataProvider="{lista.pedidos.pedido.produto}" categoryField="nome"/>
			</mx>
			<mx :series>
			</mx><mx :ColumnSeries displayName="Pedidos" yField="valor">
				</mx><mx :fill>
						<mx :SolidColor color="0x7BCE2A"/>
				</mx>
 
 
 
		<mx :Legend dataProvider="{graficocoluna}"/>
 
 
	<mx :VBox width="100%" height="50%">
		</mx><mx :DataGrid dataProvider="{graficocoluna.dataProvider}" width="100%" height="100%">
			</mx><mx :columns>
				<mx :DataGridColumn headerText="Produto" dataField="nome"/>
				<mx :DataGridColumn headerText="Preço" dataField="valor"/>
			</mx>
 
		<mx :HBox width="100%" horizontalAlign="center" height="45" verticalAlign="middle">
			<mx :Button label="Gerar PDF" click="gerarPDF()"/>
		</mx>

Ok, até ai tudo bem, geramos nosso primeiro PDF, só que é simples demais, vamos tentar adicionar uma série de opções ao meu pdf.

Outro exemplo é a adição de textos.

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
< ?xml version="1.0" encoding="utf-8"?>
<mx :Application xmlns:mx="http://www.adobe.com/2006/mxml" layout="absolute">
 
	</mx><mx :Script>
		< ![CDATA[
			import com.candymandesign.pdf.objects.APDFDocumentInfo;
			import com.candymandesign.pdf.objects.APDFormat;
			import com.igorcosta.ArquevoPDFUtil;
			import com.candymandesign.pdf.APDF;
 
 
			public function gerarPDF():void{
					var cms:APDF = new APDF();
					cms.addPage();
					cms.currentPage.addText(texto.text,10,10);
					cms.setOrientation(APDFormat.PORTRAIT);
					cms.export("http://localhost/apdf/apdf.php");
			}
 
		]]>
	</mx>
 
	<mx :Button x="500" y="370" label="Gerar PDF" click="gerarPDF()"/>
	<mx :RichTextEditor id="texto" x="239" y="31" title="Editor" width="570" height="331">
	</mx>

Criando um gerenciador de controle de impressão

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
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
< ?xml version="1.0" encoding="utf-8"?>
<mx :Application xmlns:mx="http://www.adobe.com/2006/mxml" layout="absolute">
 
</mx><mx :Script>
	< ![CDATA[
		import com.candymandesign.pdf.objects.APDFormat;
		import com.candymandesign.pdf.APDF;
 
			private var _arquevo:APDF;
 
			public function gerarPDF():void{
					_arquevo = new APDF();
					for (var i:int=1;i<=pgNumers.value;i++){
						_arquevo.addPage(String(i));
					}
					for (var j:int=0;j <_arquevo.getNumberOfPages();j++){
 
						_arquevo.getPageByID(j).addText("Algum texto criado",10,10,20);
					}
 					switch (formatoPage.selectedIndex){
							case 0:
									_arquevo.setPageSize(APDFormat.PAGE_SIZE_LETTER);
									break;
							case 1:
									_arquevo.setPageSize(APDFormat.PAGE_SIZE_A3);
									break;
							case 2:
									_arquevo.setPageSize(APDFormat.PAGE_SIZE_A4);
									break;
							case 3:
									_arquevo.setPageSize(APDFormat.PAGE_SIZE_A5);
									break;
 
							case 4: _arquevo.setPageSize(APDFormat.PAGE_SIZE_LEGAL);
									break;
 
							default:
									_arquevo.setPageSize(APDFormat.PAGE_SIZE_A4);
									break;
					}
						switch (orientacaoPage.selectedIndex){
								case 0:
									_arquevo.setOrientation(APDFormat.LANDSCAPE);
									break;
								case 1:
									_arquevo.setOrientation(APDFormat.PORTRAIT);
									break;
 
								default:
									_arquevo.setOrientation(APDFormat.PORTRAIT);
									break;
						}
		 				_arquevo.export("http://localhost/apdf/apdf.php");
			}
	]]>
</mx>
	<mx :Panel width="374" height="218" layout="absolute" title="Gerenciador APDF" x="10" top="27">
		</mx><mx :Form x="21" y="25">
			</mx><mx :FormItem label="Número de paginas">
				<mx :NumericStepper id="pgNumers" value="1" minimum="1" maximum="100" stepSize="1"/>
			</mx>
			<mx :FormItem label="Formato da pagina">
				</mx><mx :ComboBox id="formatoPage">
				</mx><mx :Array>
					</mx><mx :String> Carta </mx>
					<mx :String> A3 </mx>
					<mx :String> A4 </mx>
					<mx :String> A5 </mx>
					<mx :String> Legal </mx>
 
 
 
			<mx :FormItem label="Orientação">
				</mx><mx :ComboBox id="orientacaoPage">
				</mx><mx :Array>
					</mx><mx :String>Paisagem</mx>
					<mx :String>Vertical</mx>
 
 
 
 
		<mx :Button x="259" y="143" label="Gerar PDF" click="gerarPDF()"/>

Embora eu tenha usado o aPDF, ainda tem assunto para o próximo post, que neste caso usarei uma biblioteca mais robusta que o aPDF que é o alivePDF.

[Update] Alguns códigos exibidos neste post podem não aparecer corretamente, devido a um problema antigo em um plug-in para exibir código fonte. Pedimos desculpas.

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).