Tratamento de alterações de interface TDD

StackOverflow https://stackoverflow.com/questions/139365

  •  02-07-2019
  •  | 
  •  

Pergunta

Eu comecei a usar TDD. Conforme mencionado na uma pergunta anterior a maior dificuldade é lidar com mudanças na interface. Como você reduzir o impacto sobre seus casos de teste como a mudança de requisitos?

Foi útil?

Solução

A alteração de uma interface requer código de atualização que usa essa interface. código de teste não é diferente a partir do código não-teste neste respeito. É inevitável que os testes para que a interface terá de mudança.

Muitas vezes, quando uma interface muda você achar que "muitos" testes de ruptura, ou seja, testes de funcionalidade em grande parte não relacionada vir a depender de que interface. Isso pode ser um sinal de que seus testes são muito ampla e necessidade de refatoração. Há muitas maneiras possíveis que isso pode acontecer, mas aqui está um exemplo que esperamos que mostra a idéia geral, bem como um caso particular.

Por exemplo, se o caminho para construir um objeto conta mudou, e isso requer a atualização de todos ou a maioria dos seus testes para a sua classe Order, algo está errado. A maioria de seus testes de unidade Encomendar provavelmente não se importam sobre como uma conta é feita, portanto, testes refactor como este: 

def test_add_item_to_order(self):
    acct = Account('Joe', 'Bloggs')
    shipping_addr = Address('123 Elm St', 'etc' 'etc')
    order = Order(acct, shipping_addr)
    item = OrderItem('Purple Widget')
    order.addItem(item)
    self.assertEquals([item], order.items)

a esta: 

def make_order(self):
    acct = Account('Joe', 'Bloggs')
    shipping_addr = Address('123 Elm St', 'etc' 'etc')
    return Order(acct, shipping_addr)

def make_order_item(self):
    return OrderItem('Purple Widget')

def test_add_item_to_order(self):
    order = self.make_order()
    item = self.make_order_item()
    order.addItem(item)
    self.assertEquals([item], order.items)

Este padrão particular é um Método de Criação .

Uma vantagem aqui é que seus métodos de ensaio para a ordem são isolados como as contas e endereços são criados; se essas interfaces mudar você só tem um lugar para a mudança, em vez de todos os testes que acontece de usar contas e endereços.

Em resumo:. Testes são código também, e como todo o código, às vezes eles precisam refatoração

Outras dicas

I pensar esta é uma das razões para o argumento de moda que as interfaces são usados ??muito.

No entanto, eu discordo.

Quando os requisitos mudar - assim se seus testes. Certo? Quer dizer, se os critérios para a qual você escreveu o teste já não é válida, então você deve reescrever ou eliminar esse teste.

Espero que isso ajude, mas eu acho que pode ter entendido mal a sua pergunta.

Não serão um impacto. Você só tem que aceitar que alterar a interface vai exigir tempo para mudar os casos de teste associados em primeiro lugar. Não há maneira de contornar isso.

No entanto, em seguida, você considerar o tempo que você economizar por não tentar encontrar um bug evasivo nesta interface mais tarde e não fixar esse erro durante a semana de lançamento, é totalmente vale a pena.

Em TDD, os testes não são testes. Eles são especificações executáveis. IOW: são uma codificação executável de suas necessidades. Sempre manter isso em mente.

Agora, de repente torna-se óbvio: se os seus requisitos mudam, os testes deve mudança! Esse é o ponto de TDD!

Se você estava fazendo cachoeira, você teria que mudar o seu documento de especificação. Em TDD, você tem que fazer o mesmo, exceto que sua especificação não está escrito em Word, ele é escrito em xUnit.

"O que devemos fazer para evita o nosso código e os testes de requiments dependência? Parece que nada. Toda vez quando requiments mudou devemos mudar nosso código e testes. Mas talvez possamos simplificar o nosso trabalho? Sim, nós podemos. E o princípio-chave é:. encapsulação de código que pode ser mudado "

http://dmitry-nikolaev.blogspot.com /2009/05/atch-your-changes.html

Você escreve os testes antes de escrever o código para a nova interface.

Se você está seguindo o primeiro teste abordagem, não deve, em teoria, ter um impacto de mudanças na interface em seu código de teste. Afinal, quando você precisa alterar uma interface, você primeiro alterar o caso de teste (s) para corresponder às exigências e, em seguida, vá em frente e mudar suas interfaces / implementação até que os testes passam.

Quando interfaces de mudar, você deve esperar testes de quebrar. Se muitos testes quebrar, isso significa que o sistema está também fortemente acoplados e muitas coisas dependem dessa interface. Você deve esperar alguns testes de quebrar, mas não muito.

Tendo testes de ruptura é uma coisa boa, qualquer alteração em seu código deve quebrar testes.

Se os requisitos mudam, então os testes deve ser a primeira coisa a mudança, em vez da interface.

Gostaria de começar por modificar o design de interface no primeiro teste apropriado, atualizar a interface para passar no teste recém-quebra. Uma vez que a interface é atualizado para passar no teste, você deve ver outra quebra testes (como eles estarão usando a interface desatualizado).

Deve ser uma questão de atualizar os testes falhando restantes com o novo design de interface para obtê-los passar novamente.

Atualizando a interface de uma maneira test driven irá garantir que as mudanças são realmente necessárias, e são testáveis.

Licenciado em: CC-BY-SA com atribuição
Não afiliado a StackOverflow
scroll top