Jmine: Realizando testes de integração

A razão pela qual desenvolvemos software é porque queremos prover uma ferramenta com utilidade para um problema real de um indivíduo ou uma organização. O software gerado deve, então, ajudar pessoas a realizar tarefas relevantes para sua vida, seja automatizando algum processo ou manipulando informações úteis, tanto no contexto pessoal quanto de negócios. Criar um software e mantê-lo em produção é sempre um desafio, pois muitas vezes envolve constantemente evoluir suas funcionalidades para que o sistema permaneça útil para seus usuários o máximo de tempo possível. É muito comum encontrarmos empresas que não possuem software como seu produto principal, que gastam milhões de reais para a criação de novos sistemas como forma de investimento, esperando que os sistemas criados proporcionem melhorias significativas para os processos da empresa.

Um dos motivos pelos quais um bom software tem valor é porque podemos programar computadores para realizar tarefas complexas por nós. Desta forma, processos de negócio complexos como atividades bancárias que realizam cálculos envolvendo milhões de clientes ou a atualização de cotas de investimento podem se tornar tão simples quanto o apertar de um botão em uma tela de um sistema.

Tendo isso em vista, o grande desafio que permeia esse assunto é: como programar computadores para realizar estas tarefas de forma correta? Computadores exigem um nível muito preciso de instruções a serem realizadas, de forma que ao programar precisamos conhecer muito bem a tarefa que nosso programa deve realizar, e consequentemente o contexto de negócio que ele está inserido.

Visto que é impossível programar sem entender precisamente o que o computador deve fazer, muitas vezes a compreensão precisa da tarefa a ser realizada é um desafio. Por razões como estas, equipes de software muitas vezes possuem indivíduos com perfis bem distintos, esperando que cada perfil contribua de forma diferente para a construção deste software. Normalmente o conhecimento necessário para o desenvolvimento de um software está difundido entre usuários, clientes, analistas de negócios e outros envolvidos que não possuem domínio de programação. Ao mesmo tempo em que estes indivíduos possuem conhecimento de negócio, porém não possuem de computação, são comuns casos em que programadores entram em um projeto e sofrem para compreender as regras de negócio do sistema. Neste tipo de cenário, um programador que acabou de entrar em um projeto demora mais para produzir software com a mesma facilidade que um programador já veterano no contexto do sistema.

Além desta dificuldade, um software é um conjunto de componentes inter-relacionados, de forma que é muito comum reutilizar alguns destes componentes ao se evoluir um sistema. Por causa desta reutilização, muitas vezes componentes internos de um software são utilizados por diversas funcionalidades, e por esta razão uma simples alteração em algum deles pode impactar a estabilidade de um sistema inteiro.

Devido a esta realidade, é muito fácil ver a importância de se manter um conjunto de testes automatizados em nosso sistema. Dentre as diversas vantagens de se possuir testes automatizados de negócio em um sistema, podemos destacar:

1. Maior segurança ao realizar as alterações, pois se torna possível verificar automaticamente se o comportamento do sistema se manteve após a alteração de um ou mais componentes;

2. Possuir uma especificação executável do comportamento do sistema. Isto é, ao mantermos testes automatizados, é muito fácil distinguir o que o sistema de fato faz e o que ele não faz. Os testes definem uma especificação do software bem detalhada, a ponto de poder ser executada a qualquer momento. Além disto, um novo integrante na equipe pode compreender melhor as regras do sistema apenas ao analisar os testes;

3. Integrantes da equipe de todos os perfis (analistas, programadores, testers, usuários, clientes, etc.) podem verificar se o comportamento do sistema reflete o esperado apenas olhando para a definição dos testes automatizados, sem a necessidade de executar o sistema manualmente para realizar esta verificação.

Neste artigo, apresentaremos uma forma interessante de se criar testes de regras de negócio em um sistema Java usando planilhas eletrônicas (criadas no Microsoft Excel ou no Open Office Calc). Iniciamos descrevendo alguns conceitos a respeito de testes de software. Em seguida, abordamos um pouco a plataforma Jmine, que será utilizada para criar os testes de negócio. Por fim, vamos descrever como criar um novo projeto, implementar as regras de negócio e testar um fluxo de operação do sistema.

Conceitos iniciais

Antes de começarmos a criar os testes em nosso sistema, é importante entender os diferentes tipos de testes de software. Assim, vamos descrever três diferentes tipos:

· Testes de unidade: Esses testes são focados em testar a menor unidade de código possível. Normalmente isso significa testar um método de uma classe de forma isolada das outras classes;

· Testes de integração: Esse tipo de teste verifica o comportamento de um conjunto de unidades de código em nosso software trabalhando em conjunto. Se assumirmos que nossas unidades são métodos e classes, então um bom teste de integração irá verificar se nossas unidades estão trabalhando em conjunto da forma que deveriam. Normalmente isto é feito realizando chamadas às principais funcionalidades do sistema e verificando se o comportamento resultante é o esperado;

· Testes de aceitação: Esse tipo de teste verifica se o sistema está de acordo com os requisitos exigidos pelo cliente, tanto em termos de funcionalidades quanto em outros itens não funcionais, como desempenho, acessibilidade, ergonomia, etc.

Neste artigo iremos focar nos testes de integração, nos quais analisamos o comportamento de diversas classes em conjunto. A forma como iremos criar esses testes é através da implementação de algumas regras de negócio interligadas. Feito isso, serão realizadas chamadas a objetos do sistema responsáveis por estas regras, verificando seu resultado final e consequentemente o comportamento deles de forma integrada. Um recurso interessante que o Jmine nos provê é a possibilidade de criarmos planilhas eletrônicas para definir esses testes. A forma com que fazemos isso é descrevendo em uma planilha um conjunto de chamadas de funcionalidades de negócio e validações posteriores a serem realizadas. O Jmine é uma plataforma para desenvolvimento de aplicações web e possibilita a integração com testes automatizados de forma integrada ao modelo de desenvolvimento.

A plataforma Jmine

O Jmine é uma plataforma open source para desenvolvimento Java. Ele foi criado a partir de necessidades identificadas no desenvolvimento de sistemas corporativos em grandes organizações do setor financeiro, mas também tem sido utilizado em outros cenários como projetos open source e sistemas de mobilidade urbana.

Esta plataforma permite criarmos aplicações web integrando frameworks de mercado como o Apache Wicket, para o desenvolvimento da camada web, o Spring framework, para a injeção de dependências, e o JPA com Hibernate, para a camada de persistência. O Jmine também possui diversas ferramentas próprias para o desenvolvimento de aplicações corporativas. Alguns dos recursos mais relevantes podem ser visualizados na Figura 1. Mais informações podem ser encontradas no site do projeto e no artigo publicado na Java Magazine 115.

Figura 1. Módulos e recursos do Jmine.

Resumidamente, o Jmine nos permite criar aplicações web já configuradas com diversos recursos úteis para o dia a dia do desenvolvedor, como auxílio na integração com sistemas legados, gerenciamento de auditoria, cargas de base de dados, gerenciamento distribuído de processos batch, além do executor de testes especificados em planilhas, que é o foco deste artigo.

Por que planilhas?

Existem diversas formas de se criar testes automatizados de integração no desenvolvimento de um sistema. Uma das mais comuns em projetos Java é utilizar o próprio JUnit, que apesar de ter sido criado para testes de unidade, é muito utilizado em projetos de software para qualquer tipo de teste. Outra possibilidade é expor algumas classes de nosso sistema por meio de web services, que podem ser chamados por requisições HTTP de forma externa. Desta forma podemos testar o comportamento das unidades de nosso código de forma integrada.