Atenção: esse artigo tem um vídeo complementar. Clique e assista!
Testes unitários em aplicações que utilizam a tecnologia JSF. São apresentadas, de maneira prática, as principais características do framework JSFUnit, e como sua utilização pode auxiliar o desenvolvedor na identificação de erros na aplicação.
Para que serve:
JSFUnit é um framework de testes unitários para aplicações JSF que segue as metodologias de caixa-branca e caixa-preta. Os testes podem ser executados tanto dentro do container quanto fora, pois o framework permite que ocorram requisições HTTP reais ao servidor.
Em que situação o tema é útil:
Frameworks como WebTest, HttpUnit, HtmlUnit e Selenium testam a aplicação somente do lado cliente, pois são focados na metodologia caixa-preta de testes para aplicações web. Já com JSFUnit é possível testar tanto o lado cliente quanto o lado servidor. Assim, se o ambiente estiver dentro de um container real não há a necessidade de se criar objetos mock para a realização dos testes.
Resumo DevMan:
Iniciamos o artigo com uma breve introdução sobre testes unitários, apresentamos as características fundamentais do framework JSFUnit e seus principais benefícios. Em seguida, analisamos um simples estudo de caso, onde é demonstrado passo-a-passo como criar uma aplicação JSF 2.0 – desde a configuração do ambiente até a execução dos testes unitários utilizando o JSFUnit.
Este artigo tem como foco principal apresentar as características fundamentais do framework JSFUnit, tecnologia que auxilia no teste de aplicações que utilizam JavaServer Faces. Para garantir que o software tenha uma melhor qualidade, sendo ele web ou não, é desejável que em seu processo de desenvolvimento sejam realizados testes unitários. O teste unitário garante a qualidade do sistema, pois é ele que certifica que o código produz o resultado esperado, aumentando a qualidade do produto antes de ser entregue ao cliente.
Testes têm se tornado um aspecto importante, principalmente em aplicações corporativas. Apesar disso, atualmente existem poucos frameworks que são focados especificamente em testes unitários para aplicações JSF. Muitos dos frameworks de testes para aplicações web seguem a metodologia de caixa-preta, onde os desenvolvedores utilizam componentes web para verificar se o HTML renderizado é o esperado. Neste contexto podemos citar frameworks como HtmlUnit, HttpUnit, Canoo WebTest e Selenium, que se limitam a examinar o lado cliente das aplicações web.
A escassez de frameworks voltados à metodologia caixa-branca motivou a comunidade JBoss na criação do JSFUnit. Ele provê uma tentativa de trazer os recursos de teste para as aplicações, proporcionando uma cobertura mais ampla. Os testes são executados dentro do container, fornecendo ao desenvolvedor total acesso ao estado dos managed beans, ao FacesContext, a Expression Languages, a árvore de componentes interna e permite acesso ao HTML gerado após cada requisição.
O Que é Teste Unitário?
Devido à popularização das metodologias ágeis de desenvolvimento como a Extreme Programming (XP) e o TDD (Test Driven Development), a utilização de testes unitários foi adotada fortemente pela comunidade Java. Testes unitários são uma das práticas do XP que tem conquistado mais aceitação das equipes de desenvolvimento de software.
Um teste unitário verifica se um método produz o resultado esperado quando uma entrada conhecida é fornecida. A ideia por trás do conceito é diminuir os erros decorrentes dos projetos de software, além de melhorar o processo de implementação, promover o trabalho em equipe e servir de documentação para o desenvolvedor.
A capacidade de elaboração de testes unitários está cada vez mais sendo cobrada do profissional que trabalha com software. É de responsabilidade do programador a criação e execução de testes unitários durante a implementação do sistema. A mesma pessoa faz o planejamento, codificação e execução do teste de unidade, onde o objetivo é encontrar falhas de funcionamento dentro de uma pequena parte do sistema funcionando independentemente do todo.
A fase de testes unitários é onde se avaliam as menores unidades de software implementadas, sendo considerada uma das etapas mais importantes do desenvolvimento. Nesta técnica busca-se identificar bugs o mais cedo possível, o que pode resultar em uma excelente estratégia para obter software de melhor qualidade.
Testes em aplicações web
Aplicações web são difíceis de testar pois dependem da comunicação com o container. É bem mais complicado testar páginas web do que classes Java, pois aplicações web não permitem que verifiquemos se o conteúdo presente nas páginas é realmente o esperado. Tanto páginas JSP quanto Servlets são um tanto quanto complexas quando submetidas a testes, pois é necessário um container rodando para que suas funcionalidades sejam avaliadas. Como as páginas JSP não existem até que o deployment seja feito dentro do container web, encontramos mais um impedimento. Além disso, algumas informações importantes que precisam ser avaliadas encontram-se misturadas com tags HTML. Outro obstáculo é a mudança do layout das aplicações web, que ocorre com frequência.
JSFUnit
JSFUnit é um framework de teste para aplicações JSF que foi projetado para permitir completa integração de testes através de uma API simplificada.
Com o lançamento do JSFUnit surgiu o conceito de “acrylic box”, pois além de abranger a técnica de caixa-preta, o framework possibilita a execução de testes de caixa-branca, diferentemente de outros frameworks, tais como HtmlUnit, HttpUnit, Canoo WebTest e Selenium, que cobrem somente a técnica de caixa-preta. Como dito anteriormente, é possível criar testes funcionais utilizando JSFUnit porque o framework disponibiliza a API completa do HtmlUnit, permitindo a verificação do código gerado no cliente, além de prover acesso completo aos objetos do servidor.
Nascimento do JSFUnit
A construção do JSFUnit foi baseada em dois frameworks: HtmlUnit e Cactus. Além destes dois, alguns métodos auxiliares foram escritos para que o acesso à API do JSF estivesse disponível para nós. Em posse do FacesContext temos tudo que precisamos para verificar o que realmente acontece depois que uma requisição é feita. A seguir, veremos como o HtmlUnit e o Cactus motivaram e auxiliaram na criação do framework que é o tema deste artigo.
O Cactus é uma extensão do JUnit que pode ser utilizado para testar aplicações Web em Java. Ele oferece facilidades para testar componentes J2EE dentro de web containers, como por exemplo, Tomcat e Jetty. A execução de testes proposta pelo JSFUnit é realizada seguindo o mesmo funcionamento do JUnit. Desta forma, quem já está acostumado com testes unitários vai sentir que o impacto ao utilizar o JSFUnit será pequeno. O Cactus utiliza o container como servidor e usa o JUnit como cliente para enviar requisições para um proxy, que em seguida devolve o resultado dos testes via HTTP. Por fim, o JUnit exibe os resultados através de uma página em formato HTML.
...
