1. O que é Qunit
Quunit (http://qunitjs.com/) é uma estrutura de teste de unidade JavaScript muito poderosa que pode ajudá -lo a depurar seu código. Foi escrito por membros da equipe jQuery e é um teste oficial para o jQuery. Mas o Qunit geralmente é suficiente para testar qualquer código JavaScript regular, ele pode até testar JavaScript do lado do servidor por meio de alguns motores JavaScript, como rinoceronte ou V8.
Se você não estiver familiarizado com o conceito de "teste de unidade", não se preocupe. Isso não é muito difícil de entender:
A cópia do código é a seguinte:
Na programação de computadores, o teste de unidade (também conhecido como teste de módulo) é um teste que executa o teste de correção nos módulos do programa (a menor unidade de design de software). A unidade de programa é o menor componente testável para o aplicativo. Na programação processual, uma unidade é um único programa, função, procedimento, etc.; Para programação orientada a objetos, a menor unidade é um método, incluindo métodos nas classes base (superclasses), classes abstratas ou classes derivadas (subclasses). - Citado pela Wikipedia.
Simplificando, você escreve testes para todos os recursos do seu código e, se todos esses testes passarem, poderá ter certeza de que o código não é falho (geralmente, depende de quão completo é o seu teste).
2. Por que você deseja testar seu código
Se você nunca escreveu nenhum teste de unidade antes, poderá fazer o upload diretamente do seu código para o site, clique por um tempo para ver se surgem algum problema e tentar resolver os problemas que encontrou. Haverá muitos problemas com esse método.
Primeiro de tudo, isso é muito irritante. Clicar não é realmente um trabalho fácil, porque você precisa garantir que tudo esteja clicado e que há uma boa chance de você perder um ou dois.
Segundo, tudo o que você faz para testar não é reutilizável, o que significa que é difícil regredir. O que é retorno? Imagine que você escreveu algum código e o testou, corrija todas as falhas que encontrou e depois o publique. Neste ponto, um usuário envia alguns comentários sobre as novas falhas e requer alguns novos recursos. Você volta ao código, corrige essas novas falhas e adiciona novos recursos. O que pode acontecer a seguir é que algumas falhas antigas reaparecem, que é chamado de "retorno". Olha, agora você precisa clicar novamente, e é possível que você não consiga encontrar essas falhas antigas de carga; Mesmo se você o fizer, levará algum tempo para descobrir que seu problema é causado pela regressão. Usando testes de unidade, você escreve testes para encontrar defeitos e, uma vez que o código seja modificado, você filtra o teste novamente. Se a regressão ocorrer, alguns testes definitivamente falharão e você poderá reconhecê -los facilmente e saber qual parte do código contém o erro. Agora que você sabe o que você modificou agora, ele pode ser facilmente resolvido.
Outra vantagem dos testes de unidade, especialmente para o desenvolvimento da Web: facilita o teste de compatibilidade entre navegadores. Basta executar seus casos de teste em diferentes navegadores. Se houver um problema com um navegador, você o conserta e executa novamente esses casos de teste para garantir que não haja regressão em outros navegadores. Depois que todos eles passarem no teste, você pode dizer com certeza que todos os navegadores de destino o suportam.
Quero mencionar um projeto de John Resig: TestSwarm (http://testswarm.com/). São necessários testes de unidade JavaScript para um novo nível, ao distribuí -lo, este é um site que contém muitos casos de teste em que qualquer pessoa pode ir lá para executar alguns casos de teste e depois retornar os resultados ao servidor. Dessa forma, o código será testado muito rapidamente em diferentes navegadores ou até mesmo em plataformas diferentes.
3. Como escrever testes de unidade com trimestre
Então, como você escreve corretamente os testes de unidade com o Qunit? Primeiro, você precisa configurar um ambiente de teste:
A cópia do código é a seguinte:
<! Doctype html>
<html>
<head>
<title> suíte de teste de Qunit </ititle>
<link rel = "Stylesheet" href = "http://github.com/jquery/qunit/raw/master/qunit/qunit/qunit.css" type = "text/css" media = "screen">
<script type = "text/javascript" src = "http://github.com/jquery/qunit/raw/master/qunit/qunit/qunit.js"> </script>
<!-Seu arquivo de projeto vai aqui->
<script type = "text/javascript" src = "myProject.js"> </script>
<!-Seu arquivo de testes vai aqui->
<script type = "text/javascript" src = "mytests.js"> </sCript>
</head>
<Body>
<h1 id = "Qunit-header"> suíte de teste de trimestre </h1>
<h2 id = "Qunit-Banner"> </h2>
<div id = "Qunit-testrunner-toolbar"> </div>
<h2 id = "Qunit-useragent"> </h2>
<ol id = "Qunit-tests"> </ol>
</body>
</html>
Como você pode ver, uma versão da estrutura de Qunit gerenciada é usada aqui.
O código a ser testado foi adicionado ao myProject.js e seu teste deve ser inserido no mytest.js. Para executar esses testes, basta abrir o arquivo HTML em um navegador. Agora é hora de escrever alguns testes.
A pedra angular dos testes de unidade é a afirmação:
A afirmação é uma proposta que prevê o resultado de retorno do seu código. Se a previsão for falsa e a afirmação falhar, você sabe que algo está errado.
Execute as afirmações e você deve colocá -las no caso de teste:
A cópia do código é a seguinte:
// Vamos testar esta função
função iseven (val) {
retornar val % 2 === 0;
}
teste ('iseven ()', function () {
ok (iseven (0), 'zero é um número par');
ok (iseven (2), 'também é dois');
ok (iseven (-4), 'assim é negativo quatro');
ok (! iseven (1), 'um não é um número par');
ok (! iseven (-7), 'nem é negativo sete');
})
Aqui, definimos uma função: ISeven, que é usado para detectar se um número é um número ímpar, e queremos testar essa função para confirmar que ela não retornará a resposta errada.
Primeiro, chamamos tests (), que cria um caso de teste; O primeiro parâmetro é uma sequência a ser exibida no resultado, e o segundo parâmetro é uma função de retorno de chamada que inclui nosso mestre interrompido.
Escrevemos 5 afirmações, todas booleanas. Uma afirmação booleana que espera que seu primeiro argumento seja verdadeiro. O segundo parâmetro ainda é a mensagem a ser exibida no resultado.
Aqui está o que você deseja obter, desde que você execute o teste:
4. Referência aprofundada de aprendizado
O exposto acima apresenta apenas brevemente Qunit.js, e existem muitos métodos de afirmação. Para detalhes, consulte a documentação da API:
http://api.qunitjs.com/
O teste de unidade é uma maneira muito boa de testar seu código antes de publicá -lo. Se você não escreveu nenhum teste de unidade antes, agora é a hora de começar!