Escrevendo testes para código cujo propósito eu não entendo

58

Recentemente concluí uma refatoração de caixa preta. Não consigo fazer o check-in, porque não consigo descobrir como testá-lo.

Em um nível alto, eu tenho uma classe cuja inicialização envolve pegar valores de alguma classe B. Se a classe B está "vazia", ela gera alguns padrões sensíveis. Eu extraí essa parte para um método que inicializa a classe B para esses mesmos padrões.

Eu ainda tenho que descobrir o propósito / contexto de qualquer classe, ou como eles seriam usados. Portanto, não consigo inicializar o objeto de uma classe B vazia e verificar se ele tem os valores corretos / faz a coisa certa.

Minha melhor ideia é executar o código original, codificar os resultados dos métodos públicos, dependendo dos membros inicializados, e testar o novo código com relação a isso. Não consigo articular por que me sinto desconfortável com essa idéia.

Existe um ataque melhor aqui?

    
por JETM 23.02.2017 / 14:07
fonte

2 respostas

121

Você está indo bem!

Criar testes de regressão automatizados geralmente é a melhor coisa que você pode fazer para tornar um componente refatorável. Pode ser surpreendente, mas esses testes podem ser escritos sem o entendimento completo do que o componente faz internamente, contanto que você entenda as "interfaces" de entrada e saída (no significado geral da palavra). Fizemos isso várias vezes no passado para aplicativos legados completos, não apenas para as classes, e isso nos ajudou a evitar quebras que não entendíamos completamente.

No entanto, você deve ter dados de teste suficientes e ter certeza de que a empresa entende o que o software faz do ponto de vista de um usuário desse componente, caso contrário você corre o risco de omitir casos de teste importantes.

É IMHO uma boa ideia implementar seus testes automatizados antes de começar a refatorar, não depois, para fazer a refatoração em pequenas etapas e verificar cada etapa. A refatoração em si deve tornar o código mais legível, por isso, ajuda-o a aumentar o seu conhecimento das partes internas pouco a pouco. Portanto, as etapas da ordem nesse processo são

  1. compreenda o código "de fora",
  2. escreve testes de regressão,
  3. refatorar, o que leva a um melhor entendimento dos componentes internos do código
por 23.02.2017 / 14:30
fonte
1

Uma razão importante para escrever testes unitários é que eles documentam a API do componente de alguma forma. Não entender o propósito do código em teste é realmente um problema aqui. A cobertura do código é outro objetivo importante, difícil de alcançar sem saber quais ramificações de execução existem e como elas são acionadas.

No entanto, se for possível redefinir o estado de forma limpa (ou construir o novo objeto de teste toda vez), pode-se escrever testes de tipo "trash out-out" que apenas alimentam entradas aleatórias no sistema e observam a saída .

Tais testes são difíceis de manter, como quando eles falham, pode ser complexo dizer por que e quão sério é. A cobertura pode ser questionável. No entanto, eles ainda são muito melhores que nada. Quando tal teste falha, o desenvolvedor pode revisar as alterações mais recentes com mais atenção e, esperamos, identificar o erro lá.

    
por 24.02.2017 / 16:49
fonte