Preciso testar tudo?

28

Vou iniciar meu primeiro projeto real em Ruby on Rails e estou me forçando a escrever testes TDD . Não vejo vantagens reais em escrever testes, mas como parece muito importante, tentarei.

É necessário testar todas as partes do meu aplicativo, incluindo páginas estáticas?

Matteo Pagliazzi
fonte
9
Isso realmente não é uma questão de ruby ​​on rails. é mais uma pergunta do TDD.
Jon Strayer
4
@ JonStrayer: É? Você tem certeza de que a resposta seria a mesma para RoR e .NET? Eu sugeriria que, por design, o RoR reduziu deliberadamente o custo dos testes, embora não a segurança do tipo na forma de um compilador aumente enormemente os benefícios dos testes.
Pd #
11
Por alguma razão, essa pergunta me faz querer postar uma macro de imagem do capitão Nero gritando "TESTAR TUDO !!!"
Mason Wheeler
3
Não ver a real vantagem de escrever testes e escrevê-los com fé cega não parece realmente certo. Continue sem escrever testes, depois de um tempo você experimentará uma regressão inesperada e saberá por que está testando.
ZJR
11
Aguarde até você decidir reestruturar seu código. Sempre que mudanças maciças são introduzidas, você precisa verificar a funcionalidade. Sem testes, você precisará passar pelo aplicativo e testar todas as funcionalidades manualmente. Apresente outra grande atualização e você precisará fazer isso novamente. Os testes de unidade são apenas uma maneira 'barata' de garantir que tudo esteja funcionando conforme o esperado.
Evan Solha

Respostas:

47

TDD não é sobre testes, é sobre design. Escrever os testes obriga a pensar em como a classe deve funcionar e que tipo de interface você precisa. Os testes são um efeito colateral feliz que facilita a refatoração mais tarde.

Então, com isso em mente, qual é o comportamento de uma página estática e qual é a interface?

Minha primeira resposta seria "none" e "none".

Jon Strayer
fonte
então não há testes para páginas estáticas?
Matteo Pagliazzi 9/03/12
TDD é, até certo ponto, sobre design. Mas você ainda precisa de uma arquitetura. Sem uma arquitetura em mente, é difícil imaginar como alguém cresceria organicamente a partir de vários testes.
9788 Robert Harvey
@MatteoPagliazzi Dependendo do nível do teste (testes de unidade / testes de integração / etc), talvez um ou dois, para confirmar que as páginas estáticas estão acessíveis. Mas isso é muito alto para testes de unidade.
Izkata 9/03/12
11
@RobertHarvey Eu não disse para não testar nada. Eu disse para não testar páginas estáticas.
Jon Strayer
@ JonStrayer: TDD'ers tendem a sustentar o TDD como um elixir mágico para o design; Peço desculpas se não foi isso que você quis dizer. :)
Robert Harvey
32

É sempre uma análise de custo-benefício. Qual é o custo do recurso para você? Se o custo for alto, teste bem e completamente. Se o custo for baixo, teste levemente ou de modo algum.

Há também o custo do tempo de colocação no mercado a considerar. Talvez seja melhor você fornecer um recurso que funcione principalmente do que chegar atrasado ao fornecer um recurso totalmente funcional.

É quase impossível responder a essas perguntas na IMO geral.

Eu acho que é mais importante preservar a capacidade de testar no caso de algum recurso ser mais importante do que você imaginou originalmente.

Doug T.
fonte
Além disso, eu assumiria que erros em uma página estática seriam MUITO mais fáceis de corrigir do que erros lógicos, erros de design e o tipo de coisas que o TDD é normalmente usado para evitar. A descoberta e a correção de erros de páginas estáticas provavelmente serão bastante fáceis, e tenho a impressão de que o TDD é usado para encurtar esses dois processos quando eles demoram mais do que o desejado. : D
Gordon Gustafson
Eu não assumiria isso. Se você já lidou com comportamentos obscuros da versão do navegador ou com problemas estranhos de memória javascript, provavelmente fez um bom treino. Às vezes, os idiomas de back-end podem ser um pouco mais confiáveis ​​e padrão. as vezes. Talvez você esteja falando de estática como em html e sem javascript.
precisa
8

Eu diria "sim". Se você possui testes que abrangem até os recursos e códigos mais simples, pode ter certeza de que adicionar um novo código não faz com que o código no local pare de funcionar. Da mesma forma, fazer um teste para cada bug encontrado impede que as regressões retornem.

Bruce Ediger
fonte
"então você pode ter certeza de que a adição de novo código não faz com que o código no local pare de funcionar" dessa forma, não devo tocar em nenhum trecho de código que escrevi antes e apenas adicionar novos métodos?
Matteo Pagliazzi
Bem não. Mas dependências imprevistas e não planejadas entre o código que atualmente "funciona" podem causar problemas se você adicionar um novo código que altere essas dependências. Além disso, se você errar o teste, o que eu acho bastante comum, você deve modificar o próprio teste e, talvez, modificar o código resultante desse teste.
precisa
@ Andy Isso é um absurdo absoluto. O teste de setters e getters de propriedades é trivial e VITAL. Se eles não funcionam, geralmente toda a classe se desfaz. Por exemplo, em um aplicativo multithread, se o conjunto não impedir a obtenção simultânea, você terá um problema de dados corrompido que pode levar horas para chegar ao fundo, porque a fonte de dados estará correta, mas o resultado da obtenção Ou não, se o seu conjunto também não atualizar o tempo de atualização, seus dados poderão ficar impossíveis de sincronizar. Você entendeu. Se setters e getters estavam genuinamente trivial, você poderia apenas fazer a propriedade pública
deworde
@deworde Tenho medo de tornar os membros da instância seguros para threads não é tão comum. É mais comum controlar o acesso ao tipo de segurança que não é de rosca do que tentar torná-los seguros para threads. De qualquer forma, o que testar é uma questão de custo-benefício, como outra resposta indica. você pode gastar tempo escrevendo testes para getters ou setters ou pode testar o comportamento real que seu sistema deve encapsular.
218 Andy Andy
3

Sim, você deve testar tudo ...

Você não será capaz de escrever testes automatizados para tudo. Para suas páginas estáticas, use Selenium http://seleniumhq.org/ para garantir que as coisas estejam corretas.

Pela minha experiência, é quase impossível escrever alguns casos de front-end, mas é por isso que você realmente deseja testar usando o globo ocular Mark 1.

Schleis
fonte
Discordo. Se você não pode fazer isso acontecer por meio de simulação ou passagem de dados, por que tê-lo em seu código. Os getters e setters não precisam de seus próprios testes, pois seriam testados por meio de outros testes de unidade do sistema para verificar a funcionalidade esperada.
21312 Schleis
Claro, setters / getters são testados indiretamente com outros testes, mas quando alguém diz "testar tudo", presumo que eles significam criar testes especificamente para esse tipo de coisa. Eu sempre digo às pessoas "testam as coisas importantes". Coisas como setters e getters não se encaixam nessa definição para mim.
Andy
2

O teste é tão importante quanto a codificação. Você deve ouvir o ditado "Se algo pode dar errado, vai dar". INMO, dentre as várias técnicas de engenharia de software empregadas para aprimorar a qualidade, o teste é o mais valioso para ajudá-lo a encontrar problemas mais cedo.

Embora testar tudo não seja possível (especialmente com equipes pequenas e sistemas grandes), isso não significa que você pule o teste completamente. O teste vale a pena? Consulte a seção "Localizando falhas mais cedo" em Consulte Wiki-SoftwareTesting .

NoChance
fonte
2

Os testes TDD também podem ser especificações vivas, se escritos dessa maneira. Os nomes dos métodos de teste devem fazer sentido para um usuário comercial.

Chriseyre2000
fonte
2

Como outros já mencionaram, no teste do Ruby on Rails é muito mais importante do que na (maioria) outras línguas. Isso ocorre devido à falta de um compilador.

Idiomas como Delphi , C ++, VB.NET , etc ... são linguagens compiladas, e seu compilador irá captar muitos erros de digitação, como erros de digitação nas chamadas para um método. No Ruby on Rails, você só saberá se há um erro de digitação ou erro no seu código se essa linha de código específica for executada ou se você estiver usando um IDE que mostre avisos visuais.

Como TODAS as linhas de código são importantes (caso contrário, não estariam lá), você deve testar todos os métodos que escreve. Isso é muito mais simples do que parece, se você seguir algumas ferramentas básicas do TBDD.

Eu descobri que o Rails de Ryan Bates, lançado em How test, era inestimável para mim e realmente destacou a simplicidade do TBDD, se feito corretamente.

jamesc
fonte
1

Se você estiver realmente usando a metodologia TDD, não escreverá o código sem antes ter um teste de unidade que está tentando passar.

wessiyad
fonte
2
sim ... mas, por exemplo, em uma página estática, o que devo testar? a existência disso? que o conteúdo e os links existem? Talvez eu esteja errado, mas parece um desperdício de tempo ...
Matteo Pagliazzi
11
Costumo pensar que a metodologia TDD é aplicada à sua lógica. Sua página estática é um arquivo html? Uma visão MVC que nunca muda? Se este último caso, eu acho que você pode testar se o seu controlador retorna a visão correta. Acho que a coisa mais importante é lembrar que TDD deve ser ajudando você a desenvolver contra a sua especificação não apenas "teste" ...
wessiyad
Suponho que você simplesmente sirva uma página estática com um componente da estrutura. Se nenhum dos seus métodos estiver tocando nessa página, não há realmente nada para testar. Você também não precisa testar o Rails. Eu acho que alguém tem isso coberto.
Erik Reppen 22/03/2012
0

Eu diria para não começar com TDD. Tome uma decisão informada quando gastar mais tempo aprendendo estratégias de arquitetura em geral. O TDD não permitirá que você pule essa lição de casa, embora possa começar a acreditar que sim.

Aqui está o meu problema com isso. Quando você diz que parece gastar muito tempo com coisas que nunca quebram os TDDs, você vai gostar quando uma coisa que você não previu em uma enorme cadeia de dependências é perdida. Quando você ressalta que é impossível prever essas coisas antes de escrever seu aplicativo, o que é ... por que testamos, eles dizem que é realmente mais sobre design e não sobre testes, mesmo que o teste seja útil.

Mas as cadeias gigantes de dependências vinculadas imprevisíveis não são o produto de um design ruim?

Então qual é?

Aqui está um pensamento. Não vamos ter enormes cadeias complexas de dependências, considerando os dois princípios a seguir do design orientado a objetos do Design Patterns:

"Programa para uma interface, não uma implementação"

Ou seja, seus objetos não devem se importar com quem está chamando ou como foram feitos. Somente que os argumentos adequados foram alimentados e que os métodos que eles chamam de outros objetos são direcionados para o trabalho conforme o esperado. Sua cadeia de dependência na maioria dos casos deve estar em um ponto de ligação, a chamada do método por parte do chamador e o local onde os argumentos são inseridos nos seus métodos. É aí que você registra, valida e envia mensagens úteis para depuração quando as coisas são ruins.

E:

"Favorecer a composição do objeto sobre a herança de classe"

Quem é o boneco? O cara que fez alguma coisa para uma classe em um esquema de herança em cascata complicado envolvendo cerca de 30 aulas, resultando em quebra de casos adicionais ou o desenvolvedor que criou essa arquitetura em primeiro lugar? O TDD pode ajudá-lo a entender os problemas dentro dessa torre inclinada da classe Pisa mais cedo do que você poderia ter sem, mas isso torna menos doloroso tentar modificar um dos pontos de extremidade desse desastre de código na próxima vez?

E é aí que chego à coisa que me incomoda. O TDD realmente ajuda a projetar ou permite uma arquitetura ruim? Parece-me que tem potencial para ser uma estratégia auto-realizável. Quanto mais sua equipe não tiver responsabilidade por arquitetura ruim, mais úteis esses componentes granulares de teste parecem se tornar, mas, em última análise, seu aplicativo se tornará uma PITA cada vez maior para trabalhar (supondo que eles nunca tenham pensado muito em arquitetura no primeiro Lugar, colocar). E deixar de reconhecer as conseqüências disso é sempre o erro mais caro que você pode cometer ao trabalhar em um aplicativo que deve ser atualizado e modificado ao longo do tempo.

Erik Reppen
fonte
-1

Para responder à pergunta, pense em "o que poderia dar errado aqui". Em particular, se você alterar o "código" (marcação / qualquer que seja), como terá certeza de que não quebrou a página. Bem, para uma página estática:

  • pode não renderizar
  • pode renderizar incorretamente
  • o JS pode não carregar
  • os caminhos das imagens podem não funcionar
  • os links podem estar quebrados

Pessoalmente, eu recomendaria:

  • escreva um teste de selênio [1] que verifique se há uma sequência que você espera na página (na parte inferior, se possível). Isso valida a renderização.
  • verifique se não há erros de JS (acho que o selênio permite isso)
  • execute as páginas estáticas através de um validador html e, se possível, de um verificador de links.
  • Não encontrei uma ferramenta que eu gostaria de validar JS, mas você pode ter sucesso com jslint ou jshint.

A conclusão aqui é que você deseja algo que seja repetível, fácil de usar e seja executado automaticamente no seu executor de teste.

Paul Biggar
fonte
-1

Apenas para adicionar a todas as respostas já excelentes, eis o meu pensamento sobre o que testar e o que não testar:

Faça o teste:

  • logíca de negócios
  • lógica de aplicação
  • funcionalidade
  • comportamento,
  • então, tudo, realmente, exceto :

Não teste:

  • constantes
  • apresentação

Portanto, não faz sentido fazer um teste que diz:

assert wibble = 3

e algum código que diz

wibble = 3

E também não faz sentido testar coisas de apresentação, como se o ícone está em pervinca azul, qual fonte você usou para títulos e assim por diante ...

Então, você pergunta: "devo testar páginas estáticas", e a resposta é: você as testa na medida em que fazem parte da funcionalidade, lógica de negócios ou comportamento do seu site.

Portanto, em nosso aplicativo, temos um teste que verifica se os termos e condições estão disponíveis em todas as partes do site - para usuários anônimos, usuários logados, painel, telas internas de aplicativos etc. Apenas verifica se há um link chamado "termos e condições" em cada página, que o link funcione e, em seguida, o teste diz que, quando chega à página, "se parece com" os C & Cs - apenas o suficiente para garantir que é a página certa, sem "testar uma constante" ou "testar a apresentação" ... para que você possa verificar se o texto está correto, por exemplo, sem verificar o tamanho da fonte ou o layout do texto em particular ...

hwjp
fonte