Mostrando postagens com marcador Guice. Mostrar todas as postagens
Mostrando postagens com marcador Guice. Mostrar todas as postagens

sexta-feira, 27 de novembro de 2009

Guicifique seus Testes - Parte 6

Esta é sexta parte da tradução para português do interessante artigo Guicing Up Your Testing, June 21, 2007, por Dick Wall. Trata-se de uma leitura interessante, que junta dois tópicos que estou estudando atualmente: Teste Unitário e Google Guice, além de falar um pouco sobre Injeção de Dependências e os Padrões de Projeto Singleton e Factory.

Índice

Uma rápida reflexão sobre Design Patterns

A afirmação sobre a bala de prata se aplica, em minha opinião, tanto para o uso de bibliotecas como o Guice quanto para Design Patterns. Padrões de Projeto podem encapsular conceitos importantes, mas usá-los indiscriminadamente pode levar a problemas similares aos que tivemos ao jogar todas as responsabilidades para cima do Guice.

Lembremos que a modelagem inicial do teste estava particularmente difícil de testar justamente devido a uma aplicação pouco flexível do padrão Singleton, que era difícil de ser substituída por outra mais adequada. Uando o Guice, acabamos por aplicar o mesmo padrão Singleton, mas de forma diferente, deixando claro que a culpa não era propriamente do padrão Singleton, mas sim da forma como ele havia sido implementado.

Ainda assim, não se pode tentar pensar sempre em termos de padrões de projeto, na medida que agindo dessa forma pode-se limitar bastante as possíveis abordagens de desenvolvimento. Padrões de Projeto possuem seu valor, assim como os Anti-Patterns, e ainda mais importante, a Criatividade e o Pensamento Original e Independente.

Modelagem usando Guice e o Padrão Factory

Neste exemplo, encontrei um forte exemplar de como combinar a Injeção de Dependências oferecida pelo Guice e o Padrão de Projeto Factory. Iremos usar o Guice para criar objetos FabricaPedidos, que serão injetadas como o objeto GerenciadorTaxaJuros cofigurado nos bindings do Guice. Iremos então usar esta Fábrica para criar os objetos Pedido. Ao tirar do Guice a responsabilidade de criar os objetos da classe Pedido, ela pode voltar a ter ambos os atributos Cliente e GerenciadorTaxaJuros populados via construtor, com ambos os atributos podendo ser marcados como imutáveis.

Desta forma, corrigimos os problemas que introduzimos no código ao adaptá-lo para fazer uso da Injeção de Dependências. Vamos ao código. Na classe Pedido, reescrevemos o construtor, e retiramos a anotação @Inject (já que ela não vai mais ser diretamente gerenciada pelo Guice!).

Note que restauramos a palavra reservada final ao atributo cliente, e que o construtor recebe como argumentos tanto o GerenciadorTaxaJuros como o cliente. Como o Guice não fará mais a injeção através desta classe, criamos uma FabricaPedidos, que irá fazer este trabalho:

Não devem haver surpresas até aqui: o Guice irá injetar um GerenciadorTaxaJuros via construtor da classe FabricaPedidos. Agora, para criar um pedido, iremos chamar o método criaPedidoParaCliente, passando como parâmetro o cliente deste pedido. O método criará o Pedido, usando o GerenciadorTaxaJuros injetado pelo Guice, e o Cliente informado através da chamada da API FabricaPedidos. Vejamos o que ocorre com os testes:

Ao invés de criar um Pedido no construtor, agora criamos uma Fábrica de Pedidos. No teste, esta fábrica é usada para criar objetos Pedido, para os clientes aplicáveis. Esta implementação é muito mais limpa do que a anterior, e recuperamos a imutabilidade dos atributos da classe Pedido.

Melhorias Adicionais

Outra coisa a ser notada é que, ao invés de a busca em `GerenciadorTaxaJuros` receber como parâmetro um ID de um `Cliente`, faz mais sentido receber um objeto `Cliente`, fazendo a busca baseada neste objeto. Isto torna a API mais limpa e flexível, uma vez que permitiria que a busca possa ser parametrizada também por outros atributos da classe `Cliente`, caso conveniente. Desta forma, atualizamos a interface `GerenciadorTaxaJuros`:

E sua implementação fake:

O método `calculaTotalComTaxas` da classe `Pedido` também precisa ser refatorado para receber um objeto `Cliente` ao invés de seu ID:

A Biblioteca AssistedInject

Utilizar o padrão Factory em conjunto com Injeção de Dependências solucionou as deficiências introduzidas no final do primeiro artigo, então podemos nos perguntar se o próprio Guice não poderia oferecer alguma forma de contornar estas limitações, uma vez que elas parecem ser bem comuns.

Talvez o Guice possa, em breve. Jesse Wilson e Jerome Mourits, engenheiros da Google, criaram uma extensão do Guice chamada AssistedInject, que formaliza o uso do padrão `Factory` para ser mais facilmente utilizado com o Guice. Uma descrição do que ela faz pode ser encontrada em:

  • http://groups.google.com/group/google-guice/browse_thread/thread/9a7e2c57583d21d6
  • http://code.google.com/p/google-guice/wiki/AssistedInject

Conclusão

Vimos, portanto, que a Injeção de Dependências, por mais útil que seja, é apenas mais uma ferramenta na caixa de ferramentas. Ela pode ser utilizada com outras boas práticas e padrões de projeto quando apropriado, e quando fizer sentido. Usado corretamente, ele pode tornar mais bonitas a arquitetura e a implementação de uma aplicação.

Guicifique seus Testes - Parte 5

Esta é quinta parte da tradução para português do interessante artigo Guicing Up Your Testing, June 21, 2007, por Dick Wall. Trata-se de uma leitura interessante, que junta dois tópicos que estou estudando atualmente: Teste Unitário e Google Guice, além de falar um pouco sobre Injeção de Dependências e os Padrões de Projeto Singleton e Factory.

Índice

Não há bala de Prata

Na quarta parte desta série, precisamos refatorar a classe Pedido para que ela recebesse via construtor um objeto GerenciadorTaxaJuros. Esta medida foi necessária para que o Guice pudesse realizar a injeção de dependências via construtor. Porém, como criação de objetos Pedido agora seriam controlados pelo Guice, perdemos a liberdade de fornecer ao Pedido, via construtor, o objeto Cliente com quem ele se relaciona.

Podemos ponderar se o próprio objeto cliente poderia ter sido injetado pelo Guice, mas isso não se aplica neste caso: precisamos ter a liberdade de criar pedidos para diferentes clientes (ainda neste teste, poderíamos também incluir a checagem da taxa para um segundo cliente!), portanto a informação encapsulada pela classe Cliente está fora dos limites da classe Pedido.

Usar um método setter é a forma mais prática de contornar o problema, mas venhamos e convenhamos, ela é sub-ótima. Talvez o maior problema esteja na perda de mutabilidade: um objeto pedido existente pode ter seu cliente alterado, o que não soa particularmente seguro. Olhando por este prisma, não é desejável permitirmos que o cliente mude após ele ser atribuído ao pedido.

Poderíamos incluir código condicional dentro do setter, por exemplo lançando uma exceção em caso de tentativa de alteração, mas vamos encarar: isto começa a cheirar novamente a bacalhau.

Outro risco de permitir a mutabilidade é que alguém pode agora criar um pedido e esquecer de informar o cliente. O código (deliberadamente) não está mais protegido desta circunstância, podendo falhar com uma exceção do tipo NullPointerException ao se tentar calcular o total do pedido sem ter especificado o cliente deste pedido.

Ao me deparar com o problema da mutabilidade, isso me bloqueou por algum tempo. Certamente isso degradou aquilo que era um exemplo simples e claro em algo não tão limpo. À medida que refletia sobre isso, porém, percebi que este problema tinha valor em si!

Ele trouxe à tona um ponto importante: apesar de que a injeção de dependências seja uma ferramenta fantástica para melhorar o estilo e a modelagem de código, ela não é uma bala de prata. Da mesma forma como muitas outras ferramentas que o precederam, o Guice é surpreendentemente útil e hábil, mas não é a resposta para todos os problemas (nem mesmo para a maioria dos problemas).

Eu realmente gosto de bibliotecas que não tentam ser a solução definitiva, ao invés disso elas fazem algo específico, se propondo a fazer este algo realmente bem feito. Neste ponto, o Guice é muito bem sucedido: é a solução perfeita para Injeção de Dependências em Java: é leve, simples e rápido.

Por outro lado, mesmo um exemplo de teste bem simples evidencia algumas de suas limitações. Tão logo perdemos o controle da criação do Pedido, ao delegar este controle para o Guice, perdemos também o controle sobre a imutabilidade do atributo Cliente da classe Pedido.

Deve estar evidente que delegar ao Guice a criação direta de objetos Pedido foi uma decisão incorreta de modelagem. O problema de setar o cliente para um pedido merece uma boa solução, porém esta solução virá de um ângulo diferente daquele que nos é oferecido pela injeção de dependências. Ao invés disso, podemos mesclar esta abordagem com um outro Padrão de Projeto: Fábrica (Factory Design Pattern).

Guicifique seus Testes - Parte 4

Este artigo é quarta parte da tradução para português do interessante artigo Guicing Up Your Testing, June 21, 2007, por Dick Wall. Trata-se de uma leitura interessante, que junta dois tópicos que estou estudando atualmente: Teste Unitário e Google Guice, além de falar um pouco sobre Injeção de Dependências e os Padrões de Projeto Singleton e Factory.

Índice

Colocando o Guice em Ação

A última coisa que ainda falta fazer é fazer o setup do Guice na aplicação que ele irá rodar. Todas as peças estão no lugar agora, mas o Guice ainda não está sendo invocado em lugar algum.

Aqui está uma grande regra trazida por Zorzella e Sasha, da Google, e que é boa para se ter sempre em mente: Guice is the new "new" - em outras palavras, Guice é o nova forma de se usar o operador "new".

Numa aplicação Guice, não veremos mais tantas chamadas de construtores (new()). Ao criar um objeto usando new, não tem como envolver o Guice no processo de resolver as dependências para este objeto. Para fazer proveito do poder de autowiring, é necessário usar o Guice para criar os objetos. Vamos dar uma olhada no setup da classe de testes:

Note que pedimos ao Guice para nos retornar um gerenciadorTaxas baseado apenas na interface TaxRateManager?. Nosso código de testes, portanto, não possui mais nenhuma dependência direta a uma implementação concreta, as dependências são todas encapsuladas nas regras de binding dentro da classe ModuloTestarTaxaJuros?.

Mas espera lá, na classe ModuloTestarTaxaJuros? não definimos nenhum binding para a classe Pedido, então como é que o Guice sabe o que fazer na chamada abaixo?

O Guice possui uma regra especial para difinição de classes concretas. Como Pedido é uma classe (e não uma interface), o Guice consegue adivinhar que precisamos que ele crie um objeto desta classe para nós. Porém ele vai além, ele injeta no objeto as dependências explicitadas em seu construtor marcado com a anotação @Inject.

Agora podemos enfim chegar ao teste propriamente dito, que sofre uma ligeira alteração. Lembre que tiramos do construtor da classe Pedido o parâmetro Cliente e o colocamos em um setter. Portanto, precisamos agora fornecero cliente através deste método e não mais através do construtor:

Resultados

Depois de todo este trabalho, analisemos os resultados. Executando o teste original, simulando 5 segundos de latência para cada operação realizada no banco de dados, o JUnit mostra a seguinte saída:

Ao usar o Guice para injetar a implementação fake baseada em um HashMap?, obtemos um resultado bem mais razoável:

É uma melhoria de duas ordens de grandeza! Tudo bem, este é um exemplo inventado, mas a experiência real me diz que ele não é tão desconectado da realidade. eliminar dependências com operações de I/O, bancos de dados, serviços remotos, e assim por diante, causa uma melhoria dramática na velocidade dos testes unitários.

Isto significa que é possível rodar mais testes em menos tempo, e que estamos testando uma coisa de cada vez, sem se distrair com coisas que não têm relação direta e relevante com o teste propriamente dito (ao testar a lógica de cálculo de taxas, não há razão nenhuma de precisarmos obter informações necessariamente de um banco de dados). Ao invés disso, podemos simplesmente simular o comportamento destes componentes de baixo nível.

Guicifique seus Testes - Parte 3

Este artigo é terceira parte da tradução para português do interessante artigo Guicing Up Your Testing, June 21, 2007, por Dick Wall. Trata-se de uma leitura interessante, que junta dois tópicos que estou estudando atualmente: Teste Unitário e Google Guice, além de falar um pouco sobre Injeção de Dependências e os Padrões de Projeto Singleton e Factory.

Índice

Introdução ao Guice

Neste contexto é onde o Guice se encaixa perfeitamente. Ele nos dá o poder de definir uma configuração que mapeia as implementações de objetos a uma forma simples de localizá-los e obtê-los. Quando se pede um objeto para o Guice, ele não só irá procurar por aquele que foi solicitado, mas também irá percorrer o objeto procurando pelas suas dependências, e injetando os tipos corretos de dependência para o contexto aplicável. Ou seja, ele fará todo o trabalho de auto-conectar as dependências entre os objetos, eliminando a necessidade de injetá-las manualmente usando passagem de parâmetros pela aplicação.

Vejamos como é fácil começar a usar o Guice: baixe a versão mais atual desta biblioteca em http://code.google.com/p/google-guice, descompacte o arquivo, procure pelo arquivo guice-VERSION.jar, e adicione-o ao classpath de seu projeto. Feito isso, o Guice está pronto para usar. Ele nada mais é do que um conjunto de anotações para classes e uma simples API para configurar os módulos que irão conectar os objetos da maneira adequada. NA verdade ele é um pouco mais que isso, mas neste momento focarei apenas nas funcionalidades principais.

Voltando ao Exemplo

Vejamos o que o Guice pode fazer por nós. Primeiro, vamos deixar para o Guice a responsabilidade de preparar a classe Pedido toda vez que precisarmos utilizá-la. Sendo mais específico, queremos que o Guice forneça o GerenciadorTaxasJuros adequado para o contexto que a classe Pedido está sendo usada, seja em testes ou em produção:

As mudanças neste ponto incluem:

  • importar a anotação Inject; e
  • adicionar a anotação @Inject antes do construtor da classe Pedido.

Pode-se notar também que fizemos algumas regressões na modelagem, pois já não mais passamos um objeto Cliente através do Construtor - ao invés disso, agora ele deve ser injetado via um método setter. Desta forma, também é necessário retirar do atributo cliente o modificador final, pois para poder usar o setter, o atributo precisa ser mutável. Demos alguns passos para trás, mas voltaremos a falar sobre isso no final deste artigo.

Por agora, a anotação @Inject é a coisa mais importante a se notar. Ela indica para o Guice que ele é responsável pela construção de objetos dessa classe. Por mais que também seja possível criar objetos utilizando a classe da forma tradicional, iremos a partir de agora usar o Guice para fazer isso por nós, pois ele:

  1. Verifica que há uma anotação @Inject no nível do construtor.
  2. Verifica a assinatura dos tipos de parâmetros do construtor.
  3. Para cada um dos parâmetros, ele tenta encontrar um objeto adequado e injetar no objeto, durante a sua criação.
  4. Não há passo 4 (bom, na verdade há: se por algum motivo o Guice tiver problemas em resolver as dependências concretas que deve passar para algum parãmetro do construtor, ele automaticamente lança um erro que nos ajudará a rastrear e corrigir o problema).

Tudo isso parece mágica, mas não é. Para o Guice funcionar, informaremos a ele tudo o que ele precisa saber sobre como criar os objetos que irá injetar em cada parâmetro do construtor. Vamos juntar as peças.

Configuração dos Bindings (conexões entre objetos)

Primeramente, explique para o Guice o que você pretende fazer quando ele for solicitado para injetar um GerenciadorTaxasJuros em outro objeto (lembre que GerenciadorTaxasJuros é uma interface, então é necessário criar alguma de suas implementações concretas para que possa ser utilizado).

Para ensinar o Guice, criamos um módulo de configuração, com um binding dentro dele:

Pronto! Isto cria uma subclasse de Module explicando ao Guice que, quando você precisar de um GerenciadorTaxasJuros, o que você realmente quer, para propósitos de teste, é um objeto de GerenciadorTaxasJurosFake. Em produção, você pode ter um outro módulo que instrui o Guice a usar a implementação GerenciadorTaxasJurosBd.

É aqui que o "pulo do gato" de auto-conexão entre os objetos (auto-wiring) ocorre. Logicamente, em um sistema real, provavelmente haverão muito mais definições de binding, onde tudo o que é necessário é simplesmente adicionar mais chamadas binder.bind. Muitos erros encontrados em grandes sistemas que usam o Guice podem ocorrer devido à ausência de bindings, mas estes tipos de erro são reportados de uma maneira que se torna óbvio percebr quando algo está faltando.

Tem mais uma coisa: mencionamos antes que usar um único objeto GerenciadorTaxasJuros em toda a JVM seria uma boa idéia, porém fazer isso na forma de singleton estáticos é algo muito limitador (o alto acoplamento dificulta, entre outras coisas, escrevermos bons testes). Guice vem nos salvar deste embróglio provendo um "escopo" Singleton para podemos implementar os bindings. Uma forma de se fazer isso, é adicionar na configuração uma chamada ao método in(Scopes), onde Scopes é uma classe da API do Guice:

A outra forma, ainda mais prática, é utilizar a anotação @Singleton diretamente na definição da classe GerenciadorTaxasJurosFake.

Ambos possuem vantagens e desvantagens, porém é muito mais uma questão de preferência qual delas se deve escolher. Prefiro usar a anotação, pois ela expressa diretamente na classe GerenciadorTaxasJurosFake a intenção semântica de que um único objeto dela será criado para atender a todos as dependências a esta classe dentro da JVM.

Guicifique seus Testes - Parte 2

Este artigo é a segunda parte da tradução para português do interessante artigo Guicing Up Your Testing, June 21, 2007, por Dick Wall. Trata-se de uma leitura interessante, que junta dois tópicos que estou estudando atualmente: Teste Unitário e Google Guice, além de falar um pouco sobre Injeção de Dependências e os Padrões de Projeto Singleton e Factory.

Índice

Introdução à Injeção de Dependências

A solução mais simples é eliminar a dependência com o singleton. Para testar a classe Pedido, não há necessidade de realizar uma chamada real a um banco de dados, mesmo que o banco de dados seja rápido o suficiente. O que precisamos na classe GerenciadorTaxasJurosBD são dois métodos: atribuiTaxaParaCliente e verificaTaxaParaCliente. Este último usa o ID do cliente e retorna um double. Esta funcionalidade pode ser fornecida facilmente por um HashMap ao invés de ter que consultar o banco de dados, sendo a implementação com HashMap? mais rápida e leve.

A técnica de criar uma implementação de uma classe como esta, que imita o comportamento desejado para a implementação real, é conhecida como Fake Objects. É diferente da técnica Mock Objects, que veremos adiante (a técnica Mock Objects tem mais a ver com prover ao objeto um roteiro de passos que se espera que ele execute, e verificar se o roteiro foi realmente obedecido).

Voltando ao assunto, o que importa aqui é que para testar a classe Pedido e o seu cálculo para taxar uma determinada venda, não importa quem faz o trabalho de verificar qual o valor da taxa aplicável ao Cliente. Assumindo que o único trabalho de um GerenciadorTaxasJuros seja armazenar e recuperar a taxa usando o ID do cliente, podemos trabalhar com a seguinte implementação:



Há algumas coisas para observar aqui. Primeiro, esta implementação é bem simples. Mais importante, ela armazena tudo em memória, nunca chegando nem perto de um banco de dados, então ela tende a ser realmente eficaz para se utilizar em um teste unitário. Todos os dados necessários podem ser configurados no próprio teste, sem necessidade de armazenar nada no banco de dados.

A segunda coisa é que agora a classe agora implementa a interface GerenciadorTaxasJuros. Para a injeção de dependências funcionar, é necessário criar uma interface que a classe Pedido possa usar, ao invés de expor dentro dela uma implementação específica. A interface deve se parecer com o código abaixo:


Agora, na classe Pedido, podemos substituir todas as referências à classe GerenciadorTaxasJurosBD pela interface GerenciadorTaxasJuros. Isto nos traz toda sorte de benefícios além da testabilidade, que irei cobrir em futuros artigos?.

Em poucas palavras, tudo o que fizemos até aqui foi para eliminar uma dependência que o código tinha com uma implementação. Pedido agora não está mais amarrado a uma classe que o obriga a acessar o banco de dados. Ele agora se comunica através de uma interface, não importando para ele qual a implementação real que vai utilizar, desde que a implementação cumpra o contrato que é estabelecido pela interface.

É claro, agora é necessário, alguma forma, prover para o pedido uma implementação de GerenciadorTaxasJuros. Em produção, iremos fornecer para o pedido a implementação GerenciadorTaxasJurosBD, mas em ambiente de teste, podemos oferecer GerenciadorTaxasJurosFake, que é mais eficaz nexte contexto.

A forma mais fácil de fazer isso (sem ainda utilizar uma framework como o Guice), é simplesmente injetar a implementação desejada da interface GerenciadorTaxasJuros através do construtor da classe Pedido:


A partir de agora, todas as vezes que um pedido for criado

  • em ambiente de produção, podemos injetar um objeto GerenciadorTaxasJurosBD
  • em ambiente de testes, podemos injetar um objeto GerenciadorTaxasJurosFake, que é mais eficaz.

Se você conseguiu entender o conceito acima, você agora compreende tudo o que precisa saber sobre Injeção de Dependências. É apenas uma maneira especial de dizer para o pedido "Eu vou dizer onde você vai buscar os dados quando eu te configurar". Se isso é tudo o que tenho que falar sobre injeção de dependências, então onde é que entra o Guice?

Pense no seguinte: se você tiver que usar o construtor em toda parte em sua aplicação, o que isto acarretará ao seu código? Por um lado, você agora terá bastante trabalho adicional, tendo que passar pra lá e pra cá os objetos que deseja injetar através da aplicação. Toda vez que precisar de um Pedido, onde quer que seja na aplicação, terá de injetar manualmente uma implementação da interface GerenciadorTaxasJuros.

Posso até conseguir alguma forma mais prática de fazer isso, mas provavelmente ela provocará o mesmo tipo de inflexibilidade / acoplamento que existia quando usávamos meramente um Singleton. Logo logo o código inteiro vai estar infestado de parâmetros sendo passados via construtores ou algum outro bacalhau que vai deixar o código cada vez mais sujo.

Além disso, apesar de que um Singleton que tantas pessoas usam em aplicações Java seja um estorvo, o fato de se reutilizar um único objeto GerenciadorTaxasJuros ao invés de ter que criar um novo cada vez que precisar passá-lo ao construtor da classe Pedido, este conceito ainda é bom e desejado.

Sem falar nos problemas relacionados a Thread Safety? ou gargalos de desempenho, instanciar mais de um objeto GerenciadorTaxasJuros - um para cada Pedido - em uma única JVM seria um desperdício de memória, uma vez que todos eles realizam exatamente o mesmo trabalho (e nem mencionamos o quão caro é construir novas conexões no caso da implementação que acessa o banco de dados).

Portanto, enquanto a Injeção de Dependências resolveu o problema de alto Acomplamento, ela introduziu muito mais problemas, e não é nada prática em aplicações de grande porte. É por este motivo que outros Padrões de Projeto?, como Fábricas? e Dicionários?, entre outros, se tornaram tão populares. Eles fornecem uma forma mais organizada de localizar utilizar objetos através da aplicação.

O problema com os dicionários e fábricas é que eles são pesados e normalmente são difíceis de configurar. Eles desempenham um importante papel em grandes sistemas coporativos, mas podem ser inviáveis de se utilizar em pequenos projetos. A maioria utiliza busca de objetos por nome através de Strings, o que carrega seus próprios riscos - Strings incorretas não podem ser capturadas pelo compilador e só vão manifestar problemas em tempo de execução.

O que precisamos, portanto, é de alguma forma de "conectar" (wiring) todas essas dependências entre objetos, e esta conexão deve ser feita em tempo de execução, para evitar alto acoplamento no código. Devemos ser capazes de configurar em algum lugar qual implementação precisamos utilizar em cada circunstância, e deixar que alguma biblioteca faça o trabalho de conectar tudo, seja para testes ou para produção.

Guicifique seus Testes - Parte 1

Este artigo é primeira parte da tradução para português do interessante artigo Guicing Up Your Testing, June 21, 2007, por Dick Wall. Trata-se de uma leitura interessante, que junta dois tópicos que estou estudando atualmente: Teste Unitário e Google Guice, além de falar um pouco sobre Injeção de Dependências e os Padrões de Projeto Singleton e Factory.

Índice

Introdução

O Guice é um container leve para injeção de dependências escrito por Bob Lee e Kevin Bourrillion, da Google. Este artigo examina o caso de uso mais simples e óbvio do Guice, para simular (mock) ou imitar (fake) objetos em testes unitários.

Se você já é familiar com a idéia de Objetos Mock e Objetos Fake, este artigo pode parecer tedioso (exceto a parte do Guice, espero). Porém, se você ainda não utiliou estas técnicas, este artigo vai além de cobrir a sua utilização: vai demonstrar também como estas técnicas andam de mãos dadas com a injeção de dependências.

O Caso de Teste

Para ilustrar o uso do Guice, é necessário configurar um exemplo de teste unitário. Vou me basear em algo relativamente simples:

O sistema possui uma classe Pedido, que usa um Gerenciador de Taxas de Juros para verificar qual a taxa que incide sobre uma venda para um determinado Cliente. O pedido acrescenta o valor da taxa ao valor total dos Itens do pedido. A taxa varia de acordo com o status do cliente, então o gerenciador procura a taxa de um determinado cliente usando o seu ID. Vamos supor que o Banco de Dados onde essas taxas ficam armazenadas está sobrecarregado com muitos registros, e que leva 5 segundos para executar qualquer tipo de consulta ou atualização.

Seu objeto de testes se parecerá com isto:

Vamos dar uma olhada nesta implementação. Para o construtor, observe que:

O construtor está obtendo um objeto GerenciadorTaxasJurosBD usando o padrão Singleton, uma forma bastante comum em muitos softwares atuais. Este padrão assegura que, em toda a máquina virtual, haverá apenas um objeto deste tipo, e ele deve ser obtido através de uma chamada estática da classe GerenciadorTaxasJurosBD .

Eu pessoalmente acho que o padrão Singleton, pelo menos na forma como a maioria das pessoas o implementam (chamada estática que retorna um atributo privado interno a uma classe) é um dos mais nocivos padrões GoF (veja [http:://a.b.c livro da Gang of Four]), entre outros numerosos padrões de autoridades mundo afora. O perigo está no fato de que é muito fácil de entender, muito sedutor, mas resulta em conseqüências indesejáveis em muitos e diversos aspectos.

Neste caso em particular, a implementação de GerenciadorTaxasJurosBD na forma de um Singleton implica que, todas as vezes que você criar um Pedido, você está amarrado a uma implementação específica, a que se comunica com o Banco de Dados. Este é o problema com o Singleton: ele torna muito fácil recuperar o gerenciador de taxas que precisamos consumir, mas o preço que pagamos é que ficamos presos a uma implementação específica, com pouca flexibilidade para alterar a implementação.

Por exemplo, quando você quiser testar esta simples classe de Pedido, o teste terá que usar a implementação GerenciadorTaxasJurosBD. Isto implica em fazer um busca no banco de dados, e com a performance que supomos inicialmente, isto vai nos tomar 5 segundos a cada operação. Desta forma, no método calculaTotalComTaxa(), a chamada

demora 5 segundos para retornar. Se considerarmos que na preparação da classe de testes inserimos 2 usuários de teste:

Ao configurar dois clientes fictícios (imitando o comportamento de clientes reais) e colocá-los no Banco de Dados com duas taxas distintas, a implementação Singleton nos obriga a fazer duas operações no banco de dados, perdendo outros preciosos 10 segundos, a cada teste! Ao rodar os testes, no melhor caso (rodando apenas as 3 operações descritas acima), o teste vai demorar 15 segundos para rodas. Imagine uma centena de testes como este, cada um demorando 15 segundos cada. Você vai ter que esperar um bocado...

O singleton portanto detona o desempenho de realizar testes. Você pode melhorar a situação procurando bancos de dados mais eficientes para usar, mas ainda assim sua implementação estará acoplada e limitada a uma implementação dependente de acesso a banco de dados, o que costuma ser ineficiente.