O que é o teste de unidade?

https://stackoverflow.com/questions/1383

08-06-2019
|

Pergunta

Eu vi muitas perguntas "como" teste de unidade em um idioma específico, mas não pergunta 'o quê' e 'por que', e 'quando'.

O que é?
O que ele faz por mim?
Por que eu deveria usá-lo?
Quando devo usar (também quando não)?
Quais são algumas das armadilhas comuns e equívocos

Solução

O teste de unidade é, a grosso modo, o teste de bits do código de isolamento com o código de teste.As vantagens imediatas que vêm à mente são:

A execução de testes torna-se automatizar e repetitivo
Você pode testar em um nível muito mais granular do que o ponto-e-clique de testes, através de uma GUI

Observe que, se seu código de teste grava em um arquivo, abre uma conexão de banco de dados ou faz alguma coisa pela rede, ela é mais apropriadamente classificado como um teste de integração.Testes de integração são uma coisa boa, mas não deve ser confundida com testes de unidade.Unidade de código de teste deve ser curto, doce e rápido de executar.

Outra maneira de olhar para o teste de unidade é que você escrever os testes primeiro.Isso é conhecido como Test-Driven Development (TDD para o short).TDD traz vantagens adicionais:

Você não escrever especulativa "eu poderia precisar disso no futuro" código -- apenas o suficiente para fazer os testes passarem
O código que você escreveu é sempre coberto por testes
Escrevendo o primeiro teste, você é forçado a pensar sobre como você quer chamar o código, o que normalmente melhora o design do código, a longo prazo.

Se você não está fazendo o teste de unidade de agora, eu recomendo que você comece nele.Obter um bom livro, praticamente qualquer xUnit-book vai fazer, porque os conceitos são muito transferíveis entre si.

Às vezes escrever testes de unidade pode ser doloroso.Quando ele fica dessa forma, tentar encontrar alguém para ajudá-lo, e resistir à tentação de "escrever apenas o maldito código".O teste de unidade é muito parecido com o de lavar os pratos.Nem sempre é agradável, mas mantém o seu metafórica cozinha limpa, e você realmente quer que ele seja limpo.:)

Editar:Um equívoco vem à mente, embora eu não tenho certeza se é tão comum.Eu já ouvi de um gerente de projeto dizem que testes de unidade, a equipe escrever todo o código duas vezes.Se ele olha e se sente dessa forma, bem, você está fazendo isso errado.Não só de escrever os testes normalmente acelerar o desenvolvimento, mas também lhe dá uma conveniente "agora eu sou feito de" indicador de que você não teria de outra forma.

Outras dicas

Eu não concordo com o Dan (embora a melhor opção poderá ser apenas de não responder)...mas...

O teste de unidade é o processo de escrita do código para testar o comportamento e a funcionalidade do seu sistema.

Obviamente, testes de melhorar a qualidade de seu código, mas isso é apenas uma superficial benefício de testes de unidade.Os reais benefícios são:

Tornar mais fácil para alterar a implementação técnica, enquanto certificando-se de não alterar o comportamento (refatoração).Corretamente unidade código testado pode ser agressivamente refatorado/limpos com pouca chance de quebrar alguma coisa sem perceber.
Dar aos desenvolvedores de confiança quando a adição de comportamento ou fazer correções.
O código do documento
Indicar as áreas de código que estão intimamente ligadas.É difícil para o teste de unidade de código que é fortemente acoplados
Fornecer um meio para utilizar sua API e olhar para as dificuldades logo no início
Indica métodos e classes que não são muito coesa

Você deve teste de unidade, porque a sua em seu interesse para proporcionar uma fácil manutenção e qualidade do produto para o cliente.

Eu sugiro que você usá-lo para qualquer sistema, ou parte de um sistema, que modelos do mundo real comportamento.Em outras palavras, é particularmente bem adequada para o desenvolvimento da empresa.Eu não iria usá-lo para jogar-fora/programas utilitários.Eu não iria usá-lo para partes de um sistema que são problemáticos para testar (UI é um exemplo comum, mas que não é sempre o caso)

O maior problema é que os desenvolvedores de teste muito grande de uma unidade, ou consideram que um método de uma unidade.Isto é particularmente verdadeiro se você não entender Inversão de Controle - neste caso, os testes de unidade sempre vai se transformar em end-to-end testes de integração.Unidade de teste deve testar comportamentos individuais - e a maioria dos métodos tem muitos comportamentos.

O grande equívoco é que os programadores não deve teste.Só é ruim ou preguiçoso programadores acreditam que.Se o cara construção de seu telhado não testá-lo?Deve o médico a substituição de uma válvula cardíaca não testar a nova válvula?Apenas um programador pode testar que o seu código faz o que ele pretende fazer (QA pode testar casos extremos - como o código se comporta quando é dito para fazer coisas que o programador não tinha a intenção, e o cliente pode fazer o teste de aceitação - o código de fazer o que o que o cliente pagou por ele para fazer)

A principal diferença do teste de unidade, ao contrário de "apenas abrir um novo projeto e teste desse código específico" é que é automatizada, assim repetitivo.

Se você testar seu código manualmente, pode convencê-lo de que o código está funcionando perfeitamente - em seu estado atual.Mas o que a cerca de uma semana mais tarde, quando fez uma pequena modificação no-lo?Você está disposto a testar novamente pela mão sempre que nada alterações no seu código?Provavelmente não :-(

Mas se você pode executar os testes a qualquer momento, com um único clique, exatamente da mesma maneira, dentro de alguns segundos, e , em seguida, eles vai mostrar-lhe imediatamente sempre que algo é quebrado.E se você também integrar os testes de unidade em seu processo de compilação automatizada, eles irão alertá-lo para bugs, mesmo nos casos em que, aparentemente, completamente alheios alterar quebrou alguma coisa em um ponto distante do codebase - quando não ocorrer até mesmo para você que há uma necessidade de testar essa funcionalidade.

Esta é a principal vantagem de testes de unidade através de testes de mão.Mas espere, ainda há mais:

testes de unidade encurtar o desenvolvimento de feedback loop dramaticamente:com um teste separado departamento de ti pode levar semanas para que você saiba que há um erro no seu código, por tempo de que você já se esqueceu muito do contexto, por isso pode levar horas para encontrar e corrigir o erro;OTOH com testes de unidade, o ciclo de resposta é medido em segundos, e a correção do bug processo é geralmente ao longo das linhas de um "oh, sh*t, esqueci-me de verificar que, aqui, uma condição" :-)
testes de unidade efetivamente documento (o seu entendimento) o comportamento do seu código
o teste de unidade de força a reavaliar suas escolhas de design, o que resulta em mais simples, mais limpo design

O teste de unidade de quadros, por sua vez, torná-lo fácil para você escrever e executar testes.

Eu nunca fui ensinado a unidade de testes na universidade, e ele me levou um tempo para "pegar" a ele.Eu li sobre ele, foi "ah, certo, testes automatizados, que poderia ser legal, eu acho", e então eu esqueci sobre isso.

Demorou mais um pouco antes de eu realmente descobri o ponto:Digamos que você esteja trabalhando em um sistema de grande porte e escrever um pequeno módulo.Compila-lo, colocá-lo através de seus ritmos, ele funciona muito bem, você se move para a próxima tarefa.Nove meses para baixo da linha e duas versões depois que alguém faz uma alteração para alguns aparentemente não relacionados parte do programa, e ele quebra o módulo.Pior, eles testam suas alterações, e o seu código funciona, mas eles não testar o seu módulo;inferno, eles podem até não saber o seu módulo existe.

E agora que você tem um problema:código quebrado é no tronco e ninguém nem sabe.O melhor caso é um interno do testador encontra-lo antes de enviar, mas a fixação de um código que no final do jogo é caro.E se não testador de encontra-lo...bem, que pode ficar muito caro, de fato.

A solução é a testes de unidade.Eles vão pegar problemas quando você escrever código que é bom - mas você poderia ter feito isso com a mão.O real retorno é que eles vão pegar os problemas de nove meses abaixo da linha quando você está trabalhando agora em um completamente diferente de projeto, mas de um estagiário de verão acha que ele vai olhar mais arrumado, se esses parâmetros foram em ordem alfabética - e, em seguida, o teste de unidade que você escreveu caminho de volta a falhar, e alguém joga coisas em que o estagiário até que ele muda o parâmetro de ordem de volta. O que é o "por que" de testes de unidade.:-)

Contribui no filosófica prós de testes de unidade e TDD aqui estão algumas da chave "lâmpada" as observações que me marcou na minha tentativa primeiros passos na estrada para TDD iluminação (nenhum original ou necessariamente notícias)...

TDD NÃO significa escrever duas vezes a quantidade de código.Código de teste é, normalmente, bastante rápido e indolor para escrever e é uma parte fundamental de seu processo de criação e crítica.
TDD ajuda a perceber o momento de parar de codificação!Os testes dão-lhe a confiança que você fez o suficiente para agora e pode parar de ajustes e passar para a próxima coisa.
Os testes e o código de trabalhar em conjunto para alcançar um código melhor.Seu código pode ser ruim / buggy.O TESTE pode ser ruim / buggy.No TDD você está contando com as chances de TANTO ser ruim / buggy sendo bastante baixa.Muitas vezes, o seu teste, que precisa de conserto, mas que ainda é um bom resultado.
TDD ajuda com codificação de prisão de ventre.Sabe aquela sensação que você tem tanta coisa para fazer, você mal sabe por onde começar?É sexta-feira à tarde, se você acabou de adiar por mais um par de horas...TDD permite-lhe carne muito rapidamente o que você acha que precisa para fazer e receber o seu codificação movendo-se rapidamente.Também, como ratos de laboratório, eu acho que todos nós respondemos a essa grande luz verde e trabalhar mais para vê-lo novamente!
Em uma veia similar, estas designer de tipos pode VER o que eles estão trabalhando.Eles podem vagar por um suco / cigarro / iphone quebra e retornar para um monitor que imediatamente lhes dá uma indicação visual de como e onde eles chegaram.TDD nos dá algo semelhante.É mais fácil ver onde chegamos quando a vida intervém...
Eu acho que foi Fowler, que disse:"Imperfeitos testes, executados com freqüência, são muito melhores do que perfeito testes que nunca são escritas em tudo".Eu interpreta isso como me dando permissão para escrever testes de onde acho que vai ser mais útil mesmo se o resto do meu cobertura de código é muito incompleta.
TDD ajuda em todos os tipos de formas surpreendentes para baixo da linha.Boa testes de unidade podem ajudar documento que algo está para fazer, eles podem ajudar você a migrar o código de um projeto para outro e dar-lhe uma injustificada sentimento de superioridade sobre o seu não-testes colegas :)

Esta apresentação é uma excelente introdução para todos os gostoso bondade de teste implica.

Gostaria de recomendar o Teste xUnit Padrões livro por Gerard Meszaros.É grande, mas é um grande recurso sobre os testes de unidade.Aqui está um link para o seu site onde ele discute os conceitos básicos de testes de unidade. http://xunitpatterns.com/XUnitBasics.html

Eu uso de testes de unidade para poupar tempo.

Quando criar a lógica de negócios (ou de acesso a dados) testes de funcionalidade muitas vezes pode implicar digitando coisas em um monte de telas que podem ou não estar concluído ainda.Automatizar esses testes economiza tempo.

Para mim, os testes de unidade são uma espécie de modularizados de equipamento de teste.Normalmente, há pelo menos um ensaio por função pública.Eu escrevo testes adicionais para cobrir os vários comportamentos.

Todos os casos especiais em que você pensou quando a desenvolver o código pode ser registrado no código em testes de unidade.Os testes de unidade também se tornar uma fonte de exemplos sobre como usar o código.

É muito mais rápido para eu descobrir que o meu novo código de quebra de alguma coisa na minha testes de unidade, em seguida, verifique o código e ter algum desenvolvedor front-end encontrar um problema.

Para acesso a dados de teste eu tento escrever testes que não têm qualquer alteração ou limpar depois de si.

Testes de unidade, não vão ser capazes de resolver todos os requisitos de teste.Eles serão capazes de salvar o tempo de desenvolvimento e teste de núcleo de partes da aplicação.

Esta é a minha opinião sobre isso.Eu diria que o teste de unidade é a prática de escrever testes de software para verificar se o software faz o que é suposto.Isso começou com jUnit no mundo Java e tornou-se uma prática recomendada em PHP, bem como com SimpleTest e phpUnit.É um núcleo de práticas de Extreme Programming e ajuda a você ter certeza de que o seu software ainda funciona como previsto depois de editar.Se você tem suficiente cobertura de teste, você pode fazer grandes refatoração, resolução de bug ou adicionar funcionalidades rapidamente com muito menos medo da introdução de outros problemas.

É mais eficaz quando todos os testes de unidade pode ser executado automaticamente.

O teste de unidade é geralmente associado com OO desenvolvimento.A idéia básica é criar um script que configura o ambiente para o seu código e, em seguida, exercícios de ti;você escreve afirmações, especifique a intenção de saída que você deve receber e, em seguida, executar o seu script de teste usando um framework, tais como os mencionados acima.

O quadro irá executar todos os testes contra o seu código e, em seguida, relatar de volta o sucesso ou fracasso de cada teste.phpUnit é executado a partir da linha de comando do Linux por padrão, embora existam HTTP interfaces disponíveis para ele.SimpleTest é baseado na web, por natureza, e é muito mais fácil para se levantar e correr, IMO.Em combinação com o xDebug, phpUnit pode dar-lhe automatizado estatísticas para cobertura de código que algumas pessoas acham muito útil.

Algumas equipes escrever ganchos de seu repositório subversion para que testes de unidade são executados automaticamente, sempre que você cometer alterações.

É uma boa prática para manter seus testes de unidade no mesmo repositório, pois sua aplicação.

Bibliotecas como O NUnit, xUnit ou JUnit são apenas obrigatório se você quiser desenvolver seus projetos, usando o TDD abordagem popularizado por Kent Beck:

Você pode ler Introdução ao Desenvolvimento Orientado a testes (TDD) ou Kent Beck livro Desenvolvimento Orientado A Testes:Por Exemplo.

Então, se você quer garantir que seus testes de cobertura de uma "boa" parte do seu código, você pode utilizar um software como o NCover, JCover, PartCover ou seja o que for.Eles vão te dizer que o percentual de cobertura de código.Dependendo de quanto você é adepto de TDD, você vai saber se você já praticou-o suficientemente bem :)

Teste de unidade é o teste de uma unidade de código (por exemplo,uma única função, sem a necessidade de infra-estrutura que a unidade de código depende.i.e.teste-o em isolamento.

Se, por exemplo, a função que você está testando se conecta a um banco de dados e não uma atualização, em um teste de unidade, você não pode querer fazer essa atualização.Você seria se fosse um teste de integração, mas neste caso não.

Assim, um teste de unidade exerceria a funcionalidade entre a "função" o que você está testando, sem efeitos colaterais da atualização do banco de dados.

Dizer que sua função recuperados alguns números a partir de um banco de dados e, em seguida, realizou um cálculo de desvio padrão.O que você está tentando testar aqui?Que o desvio padrão é calculado corretamente ou que os dados são retornados do banco de dados?

Em um teste de unidade que você quer apenas testar que o desvio padrão é calculado corretamente.Em um teste de integração que você deseja testar o cálculo de desvio padrão e o banco de dados de recuperação.

O teste de unidade é sobre como escrever código que testa o código de sua aplicação.

O Unidade a parte do nome que é sobre a intenção de testar pequenas unidades de código (um método, por exemplo) de cada vez.

xUnit está lá para ajudar com este teste, eles são estruturas que ajudar com isso.Parte do que é teste automatizado corredores que dizer a você o que de teste falhar e quais passar.

Eles também têm comodidades para instalação de código comum que você precisa em cada teste antes da mão e derrubá-lo quando todos os testes acabados.

Você pode ter um teste para verificar que espera-se uma exceção foi acionada, sem ter para escrever todo o bloco catch tente você mesmo.

Acho que o ponto que você não entende é que o teste de unidade de frameworks como o NUnit (e como) vai ajudar você a automatizar de pequeno e médio porte testes.Normalmente, você pode executar os testes em uma GUI (que é o caso com O NUnit, por exemplo) simplesmente clicando em um botão e, em seguida, - tomara - ver a barra de progresso ficar verde.Se ele ficar vermelho, o quadro mostra que o teste falhou e o que exatamente deu errado.Em uma unidade normal de teste, você costuma usar afirmações, e.g. Assert.AreEqual(expectedValue, actualValue, "some description") - então, se os dois valores forem diferentes, você verá um erro dizendo que "alguns descrição:o esperado <expectedValue> mas foi <actualValue>".

Então, como conclusão de teste de unidade irá tornar o teste mais rápido e muito mais confortável para os desenvolvedores.Você pode executar todos os testes de unidade antes de cometer novo código para que você não quebre o processo de criação de outros desenvolvedores de um mesmo projeto.

Utilização Testivus.Tudo o que você precisa saber está lá :)

O teste de unidade é uma prática para certificar-se de que a função ou módulo que você vai implementar vai se comportar conforme o esperado (requisitos) e também para certificar-se de como ele se comporta em situações como condições de contorno, e uma entrada inválida.

xUnit, O NUnit, o mbunit, etc.são ferramentas que ajuda você a escrever os testes.

Desenvolvimento Orientado a testes tem uma espécie de cuidado com o termo Teste de Unidade.Como um veterano vou mencionar o mais genérico definição.

Teste de unidade também significa testar um único componente de um sistema maior.Este único componente pode ser uma dll, exe, biblioteca de classe, etc.Ele poderia até mesmo ser um único sistema em um sistema multi-aplicação.Assim, em última análise, o Teste de Unidade acaba sendo o teste de tudo o que você quiser chamar uma única peça de um sistema maior.

Você, em seguida, mover para cima integrado ou sistema de teste através do teste como todos os componentes trabalham em conjunto.

Primeiro de tudo, seja falando sobre testes de Unidade ou quaisquer outros tipos de testes automatizados (Integração, Carga, INTERFACE do usuário de teste, etc.), a principal diferença de que você sugere é que ele é automático, repetitivo e que não necessita de quaisquer recursos humanos para ser consumido (= ninguém tem para realizar os testes, eles geralmente são executados em um premir de um botão).

Eu fui a uma apresentação sobre testes de unidade em FoxForward 2007 e foi-me dito que nunca a unidade de teste de qualquer coisa que funciona com os dados.Afinal, se você testar em viver de dados, os resultados são imprevisíveis, e se você não testar no viver de dados, você não está realmente testar o código que você escreveu.Infelizmente, isso é mais do que a codificação de eu fazer estes dias.:-)

Eu fiz levar um tiro TDD recentemente, quando eu estava escrevendo uma rotina para salvar e restaurar as configurações.Primeiramente, verifico que eu poderia criar o objeto de armazenamento.Então, que ele tinha o método que eu precisava chamar.Então, que eu poderia chamá-lo.Então, que eu poderia passar parâmetros.Então, que eu poderia passar parâmetros específicos.E assim por diante, até que eu finalmente fui verificando que ele iria salvar a configuração especificada, me permite alterar e, em seguida, restaurá-lo, para várias sintaxes diferentes.

Eu não chegar ao fim, porque eu precisava-a-rotina-agora-caramba, mas foi um bom exercício.

O que fazer se você receber um monte de porcaria e parecer que você está preso em um perpétuo estado de limpeza que você sabe que com a adição de novas funcionalidades ou de código pode quebrar a corrente definida porque o software atual é como um castelo de cartas?

Como podemos fazer o teste de unidade, então?

Você começar pequeno.O projeto eu só tenho não tinha testes de unidade até poucos meses atrás.Quando a cobertura foi de que os baixos, nós simplesmente escolher um arquivo que não tinha cobertura e clique em "adicionar testes".

Agora estamos até mais de 40%, e conseguimos pegar a maioria dos fruta mais baixa.

(A melhor parte é que, mesmo com este baixo nível de cobertura, nós já executados em muitos casos, do código fazendo a coisa errada, e o teste pegou.Que é um grande motivador para empurrar as pessoas para adicionar mais testes.)

Isso responde por que você deve fazer o teste de unidade.

Os 3 vídeos abaixo de cobertura de testes de unidade em javascript, mas os princípios gerais se aplicam na maioria dos idiomas.

Testes De Unidade:Minutos Agora Vai Economizar Horas Mais Tarde - Eric Mann - https://www.youtube.com/watch?v=_UmmaPe8Bzc

JS Testes de Unidade (muito boa) - https://www.youtube.com/watch?v=-IYqgx8JxlU

Escrito Testável JavaScript https://www.youtube.com/watch?v=OzjogCFO4Zo

Agora eu estou começando a aprender sobre o assunto para que eu possa não estar 100% correto, e há mais do que o que eu estou descrevendo aqui, mas o meu entendimento básico de teste de unidade é que você escrever algum código de teste (que é mantido separado do seu código principal) que chama uma função em seu código principal com entrada (argumentos) que a função exige, e em seguida, o código verifica se o que recebe de volta válido o valor de retorno.Se ele não receber de volta um valor válido o teste de unidade framework que você está usando para executar os testes mostra uma luz verde (tudo de bom) se o valor é inválido você obter uma luz vermelha e, em seguida, você pode corrigir o problema imediatamente antes de liberar o novo código de produção, sem a realização de testes que você pode realmente não ter pego o erro.

Então você escrever testes para você o código actual e criar o código de modo que ele passa no teste.Meses mais tarde, você ou alguém precisa modificar a função no código principal, porque no início você já tinha escrito o código de teste para que a função executar agora novamente e o teste pode falhar porque o codificador introduzido um erro de lógica na função ou retorno de algo completamente diferente do que o que a função deve retornar.Novamente sem o teste no lugar que o erro pode ser difícil de rastrear como ele pode afetar o outro código bem e vai passar despercebida.

Também o fato de que você tem um programa de computador que é executado através de seu código e testes, em vez de manualmente fazê-lo no navegador, página por página poupa tempo (unidade de testes para javascript).Vamos dizer que você modificar uma função que é usada por alguns script em uma página da web e funciona tudo muito bem para a sua nova finalidade a que se destina.Mas, vamos dizer também, por causa dos argumentos que há uma outra função em outro lugar no seu código que depende de que o recém-função modificada para que funcione corretamente.Esta função dependente agora pode parar de funcionar devido a alterações que você fez para a primeira função, no entanto, sem testes que são executados automaticamente pelo seu computador, você não vai notar que há um problema com essa função até que seja realmente executada e você vai ter que navegar manualmente para uma página da web que inclui o script que executa a função de dependentes, só então você percebe que há um bug devido a alteração que você fez para a primeira função.

Para reiterar, a realização de exames que são executados durante o desenvolvimento de seu aplicativo vai pegar estes tipos de problemas que você está codificando.Não tendo os testes no lugar que você teria que ir manualmente através de toda a sua aplicação e, mesmo assim, pode ser difícil identificar o erro, ingenuamente você enviá-la para a produção, e depois de um tempo um tipo de utilizador envia um relatório de bug (que não vai ser tão boa como as mensagens de erro em uma estrutura de teste).

É muito confuso quando você ouvir o assunto e você pensa consigo mesmo, não sou eu já testar o meu código?E o código que você escreveu está a funcionar como é suposto para já, "por que eu preciso de um outro quadro?"...Sim, você está já a testar o seu código, mas é melhor fazê-lo.Você apenas tem que escrever bons testes suficientes para uma função/unidade de código uma vez e o resto é tomado cuidado de, por você, por o poderoso cpu em vez de você ter de verificar manualmente se todo o seu código ainda está trabalhando quando você faz uma alteração em seu código.

Além disso, você não precisa de teste de unidade de código, se você não quer, mas vale a pena conforme o seu projeto/código da base de dados começa a crescer à medida que as chances de introdução de erros aumenta.

Teste de unidade e TDD, em geral, permite que você tenha mais curtos ciclos de retorno sobre o software que você está a escrever.Em vez de ter uma grande fase de teste no final da execução, é incrementalmente testar tudo o que você escreve.Isso aumenta a qualidade de código muito, como você vê imediatamente, onde você pode ter bugs.

Licenciado em: CC-BY-SA com atribuição

Não afiliado a StackOverflow