O que é um “Stub”?

Então, continuando com a minha resolução de ano novo de entrar mais no TDD, agora estou começando a trabalhar mais com Rhino Mocks .

Uma coisa que estou ansioso para fazer é ter certeza de que realmente groco no que estou entrando, então eu queria verificar meu entendimento do que vi até agora (e pensei que seria bom trazer isso aqui como um recurso).

O que é um "Stub"?

Martin Fowler escreveu um excelente artigo sobre esse assunto. Desse artigo:

Meszaros usa o termo Teste Duplo como o termo genérico para qualquer tipo de objeto falso usado no lugar de um objeto real para fins de teste. O nome vem da noção de um dublê nos filmes. (Um de seus objetivos era evitar o uso de qualquer nome que já fosse amplamente utilizado.) Meszaros então definiu quatro tipos específicos de duplo:

• Objetos fictícios são passados, mas nunca realmente usados. Normalmente, eles são usados ​​apenas para preencher listas de parâmetros.
• Objetos falsos, na verdade, têm implementações funcionais, mas geralmente usam algum atalho que os torna inadequados para produção (um banco de dados na memória é um bom exemplo).
• Os stubs fornecem respostas automáticas para chamadas feitas durante o teste, geralmente sem responder a nada fora do que está programado para o teste. Os stubs também podem registrar informações sobre chamadas, como um stub de gateway de e-mail que lembra as mensagens que "enviou" ou talvez apenas quantas mensagens "enviou".
• Mocks é o que estamos falando aqui: objetos pré-programados com expectativas que formam uma especificação das chamadas que eles devem receber.

Para colocar em minhas próprias palavras: os objetos simulados "esperam" que certos métodos sejam chamados neles e normalmente fazem com que um teste de unidade falhe se suas expectativas não forem atendidas. Objetos stub fornecem respostas prontas (e podem ser gerados automaticamente por bibliotecas auxiliares), mas normalmente não causam diretamente a falha do teste de unidade. Eles são normalmente usados ​​apenas para que o objeto que você está testando obtenha os dados de que precisa para fazer seu trabalho.

Um "esboço" é uma implementação de uma interface que existe para fornecer dados / uma resposta de algum tipo. Por exemplo:

• um DataSet
• lista de usuários
• um arquivo xml

Normalmente, isso seria fornecido por outro serviço (seja um serviço da Web, outro aplicativo, um banco de dados), mas para melhorar a testabilidade do código, os resultados são "falsos".

Um grande benefício disso é que permite que as afirmações sejam feitas em testes de unidade com base nos dados esperados. Se ocorrerem erros devido a erros de dados, os testes podem ser facilmente adicionados, um novo stub criado (replicando o erro de dados) e o código produzido para corrigir o erro.

Stubs diferem de Mocks porque são usados ​​para representar e testar o estado de um objeto, enquanto um Mock testa sua interação .

Eu acredito que "stub" vem de STartUpBlock. é usado para se referir a partes do código que são geradas automaticamente para ajudar você, o desenvolvedor, a começar.

Um "stub" ou "método stub" é projetado para ser um código inicial ou um substituto temporário para o código ainda a ser desenvolvido. É um código integrado gerado por um IDE. Os métodos stub são, na verdade, métodos usados ​​para testar métodos de uma classe específica. Ele é usado inserindo alguns valores para as variáveis ​​locais em seus métodos de desenvolvimento reais e verifique se a saída está correta. É importante para encontrar bugs em seu código.

Enfrentei a questão recentemente e reconheci que esta comparação entre Stub e Driver é realmente clara e útil:

Basicamente, stubs e drivers são rotinas que não fazem nada, exceto se declarar e os parâmetros que aceitam. O restante do código pode então pegar esses parâmetros e usá-los como entradas.

+ --------- + ------------------------------- + ------- ------------------------ +
| | Stub | Driver |
+ --------- + ------------------------------- + ------- ------------------------ +
| Tipo | Códigos fictícios | Códigos fictícios |
+ --------- + ------------------------------- + ------- ------------------------ +
| Usado em | Integração de cima para baixo | Integração Bottom Up |
+ --------- + ------------------------------- + ------- ------------------------ +
| Objetivo | Para permitir o teste da parte superior | Para permitir o teste do inferior |
| | níveis do código, quando o | níveis do código, quando o |
| | níveis mais baixos do código são | os níveis superiores do código são |
| | ainda não desenvolvido. | ainda não desenvolvido. |
+ --------- + ------------------------------- + ------- ------------------------ +
| Exemplo | A e B são componentes. | A e B são componentes. |
| | A ---> B | A ---> B |
| | | |
| | A foi desenvolvido. | Um ainda precisa ser desenvolvido.
| | B ainda precisa ser desenvolvido. B foi desenvolvido. |
| | Portanto, o stub é usado | Portanto, o driver é usado |
| | no lugar de B para imitá-lo. | no lugar de A para imitá-lo |
| | | |
| | A ---> Stub | Driver ---> B |
+ --------- + ------------------------------- + ------- ------------------------ +

Da diferença entre stub e driver

Depois de alguma pesquisa e com base em arquivos stub que enfrentei durante minha vida de codificador, eu diria que um arquivo stub é apenas um arquivo que contém uma parte ou parte da implementação de um arquivo. Ajuda os desenvolvedores a começar a programar.