Como os objetos simulados são comumente mal utilizados?

Li recentemente um artigo que dizia que objetos simulados geralmente são mal compreendidos e mal utilizados. Existem claros anti-padrões zombeteiros que eu posso observar?

Eu odeio ver simples classes concretas ridicularizadas. Por exemplo, considere a seguinte classe simples, que não depende de mais nada:

public class Person
{
    private readonly string _firstName;
    private readonly string _surname;

    public Person(string firstName, string surname)
    {
        if (String.IsNullOrEmpty(firstName))
        {
            throw new ArgumentException("Must have first name");
        }

        if (String.IsNullOrEmpty(surname))
        {
            throw new ArgumentException("Must have a surname");
        }

        _firstName = firstName;
        _surname = surname;
    }

    public string Name 
    {
        get
        {
            return _firstName + " " + _surname;
        }
    }
}

Em todos os testes que envolvem essa classe, eu prefiro que um real seja instanciado e usado, em vez de alguma interface como 'IPerson' sendo retirada, uma zombada usada e expectativas definidas no. Ao usar o real, seu teste é mais realista (você tem as verificações de parâmetros em vigor e a implementação real da propriedade 'Nome'). Para uma classe simples como essa, você não está tornando seus testes mais lentos, menos determinísticos ou atrapalhando a lógica (não é provável que você precise saber que Nome foi chamado ao testar alguma outra classe) - que são os motivos habituais para zombar / stubbing.

Como uma extensão disso, também vi pessoas escreverem testes nos quais o mock é configurado com uma expectativa, e o mock é chamado diretamente no teste. Sem surpresa, o teste sempre passa ... hmmmm ...

Pode parecer óbvio, mas: Não use objetos simulados no código de produção! Eu já vi mais de um exemplo em que o código de produção dependia das características de certos objetos simulados ( MockHttpServletRequestdo Springframework, por exemplo).

Na minha opinião, é a verificação de invocação excessiva de método em zombarias. Eu sinto que essa é uma prática imposta por algumas estruturas de simulação, como o EasyMock, onde o comportamento padrão de simulação é falhar sempre que houver uma chamada de método adicional que não era exatamente especificada anteriormente. Esse tipo de verificação estrita do método simulado pode levar a projetos frágeis, nos quais a menor alteração no código pode levar a um conjunto de testes falhando, mesmo que a funcionalidade principal ainda seja a mesma.

Uma solução para isso está começando a usar stubs em vez de zombarias. Um artigo que achei particularmente esclarecedor sobre o assunto foi encontrado no Javadoc de Mockito: http://docs.mockito.googlecode.com/hg/org/mockito/Mockito.html (consulte "2. Que tal uma punhalada?" ), com link para: http://monkeyisland.pl/2008/07/12/should-i-worry-about-the-unexpected/ .

Até agora, gostei de trabalhar com o Mockito, porque ele não impõe esse comportamento estrito de zombaria, mas o uso de stubs. Também impõe a verificação de métodos específicos, em vez de todo o objeto simulado; então você acaba verificando apenas os métodos que realmente importam no seu cenário de teste.

Existem alguns livros aqui e ali, posso recomendar que abordem esse assunto e que sejam zombeteiros e gerais:

Padrões xUnit

A arte do teste de unidade: com exemplos em .Net

Teste Java de próxima geração: TestNG e conceitos avançados (este livro é principalmente sobre testNG, mas há um bom capítulo sobre zombaria)

Eu observei poucos anti-padrões em minha experiência.

• Classes de domínio sendo ridicularizadas / stub em que uma mudança de estado pode ocorrer e que precisa ser verificada.
• Testes de integração interagindo com uma mistura de zombarias e classes concretas que anulam o objetivo dos testes de integração.
• Uso inadvertido de zombarias no código de produção (isso nunca deve acontecer)

Caso contrário, minha experiência com zombarias, especialmente Mockito, foi fácil. Eles tornaram os testes muito fáceis de escrever e manter. O teste de interação do modo de exibição / apresentador do GWT é muito mais fácil com as simulações do que o GWTTestCase.

Acho que os testes que utilizam simulações em várias camadas de um aplicativo são particularmente difíceis de decifrar e alterar. No entanto, acho que isso foi atenuado nos últimos anos por APIs de frameworks simuladas aprimoradas (eu uso o JMock quando conveniente).

Há 5 ou 6 anos, APIs como o EasyMock eram poderosas, mas muito pesadas. Frequentemente, o código de teste que o utilizava era ordens de magnitude mais complicadas do que o código que estava testando. Naquela época, eu tentei influenciar as equipes em que eu estava para usá-lo com moderação e se contentar com zombarias artesanais simples que eram simplesmente implementações alternativas de interfaces especificamente para testes.

Recentemente, minhas opiniões fortes sobre isso se tornaram mais suaves, pois as APIs de zombaria tornaram os testes que os utilizam mais legíveis. Essencialmente, quero que meu código (incluindo testes) seja alterável por outros desenvolvedores sem fazê-los sentir como se estivessem analisando um atoleiro de chamadas obscuras de API.