Analisei e considerei muitos testes de unidade JavaScript e ferramentas de teste, mas não consegui encontrar uma opção adequada para permanecer totalmente compatível com TDD. Portanto, existe uma ferramenta de teste de unidade JavaScript totalmente compatível com TDD?

Karma ou transferidor

Karma é um executor de testes JavaScript criado com o Node.js e destinado a testes de unidade.

O transferidor é para teste de ponta a ponta e usa o Selenium Web Driver para conduzir testes.

Ambos foram feitos pela equipe Angular. Você pode usar qualquer biblioteca de asserções que desejar.

Screencast: Karma Introdução

relacionados :

• Devo usar o transferidor ou o karma para meus testes de ponta a ponta?
• Transferidor e Karma podem ser usados ​​juntos?

profissionais :

• Usa o node.js, tão compatível com o Win / OS X / Linux
• Execute testes de um navegador ou sem cabeça com o PhantomJS
• Executar em vários clientes ao mesmo tempo
• Opção para iniciar, capturar e desligar automaticamente navegadores
• Opção para executar servidor / clientes no computador de desenvolvimento ou separadamente
• Execute testes a partir de uma linha de comando (pode ser integrado ao ant / maven)
• Escreva testes no estilo xUnit ou BDD
• Suporta várias estruturas de teste JavaScript
• Executar testes automaticamente ao salvar
• Proxies solicita vários domínios
• Possível personalizar:
  • Estenda-o para agrupar outras estruturas de teste (Jasmine, Mocha, QUnit interno)
  • Suas próprias afirmações / refutações
  • Repórteres
  • Lançadores de Navegador
• Plugin para WebStorm
• Suportado pelo Netbeans IDE

Contras :

• Será que não suporta NodeJS (ie backend) teste
• Nenhum plugin para Eclipse (ainda)
• Sem histórico de resultados de testes anteriores

mocha.js

Estou totalmente sem qualificação para comentar sobre os recursos, pontos fortes e fracos do mocha.js, mas isso me foi recomendado por alguém em quem eu confio na comunidade JS.

Lista de recursos, conforme relatado por seu site:

• suporte ao navegador
• suporte assíncrono simples, incluindo promessas
• relatórios de cobertura de teste
• suporte a diff de string
• javascript # API para executar testes
• status de saída adequado para suporte de IC, etc.
• detecta automaticamente e desativa a coloração para não-ttys
• mapeia exceções não capturadas para o caso de teste correto
• suporte de tempo limite de teste assíncrono
• tempos limite específicos de teste
• suporte de notificação de rosnado
• relata durações de teste
• destaca testes lentos
• suporte para observador de arquivos
• detecção de vazamento variável global
• opcionalmente, execute testes que correspondem a uma regexp
• saída automática para evitar "travamento" com um loop ativo
• meta-gerar facilmente suítes e casos de teste
• Suporte ao arquivo mocha.opts
• títulos clicáveis ​​do conjunto para filtrar a execução do teste
• suporte ao depurador de nós
• detecta várias chamadas para done ()
• use qualquer biblioteca de asserções que desejar
• relatórios extensíveis, agrupados com mais de 9 repórteres
• DSLs de teste extensíveis ou "interfaces"
• antes, depois, antes de cada, depois de cada gancho
• suporte arbitrário ao transpiler (script café etc)
• Pacote TextMate

yolpo

Esta não existir mais, redirecionamentos para sequential.js vez

Yolpo é uma ferramenta para visualizar a execução de javascript. Os desenvolvedores de API Javascript são incentivados a escrever seus casos de uso para mostrar e informar sua API. Esses casos de uso formam a base dos testes de regressão.

AVA

Executor de teste futurista com suporte integrado para o ES2015. Embora o JavaScript seja de thread único, as E / S no Node.js podem ocorrer em paralelo devido à sua natureza assíncrona. O AVA tira proveito disso e executa seus testes simultaneamente, o que é especialmente benéfico para testes pesados ​​de IO. Além disso, os arquivos de teste são executados em paralelo como processos separados, oferecendo desempenho ainda melhor e um ambiente isolado para cada arquivo de teste.

• Mínimo e rápido
• Sintaxe de teste simples
• Executa testes simultaneamente
• Força a gravação de testes atômicos
• Globais implícitos
• Ambiente isolado para cada arquivo de teste
• Escreva seus testes no ES2015
• Prometer suporte
• Suporte à função de gerador
• Suporte de função assíncrona
• Suporte observável
• Declarações aprimoradas
• TAP ou saída opcional
• Rastreios de pilha limpos

Buster.js

Um executor de teste JavaScript criado com Node.js. Muito modular e flexível. Ele vem com sua própria biblioteca de asserções, mas você pode adicionar sua própria, se quiser. A biblioteca de asserções é dissociada, para que você também possa usá-la com outros executores de teste. Em vez de usar assert(!...)or expect(...).not..., ele usa o refute(...)que é uma imho agradável.

Um kit de ferramentas de teste de JavaScript do navegador. Realiza testes de navegador com automação de navegador (pense em JsTestDriver), teste estático de página HTML no estilo QUnit, teste em navegadores sem cabeça (PhantomJS, jsdom, ...) e muito mais. Dê uma olhada na visão geral !

Um kit de ferramentas de teste do Node.js. Você obtém a mesma biblioteca de casos de teste, biblioteca de asserções etc. Isso também é ótimo para o navegador híbrido e o código Node.js. Escreva seu caso de teste com o Buster.JS e execute-o no Node.js e em um navegador real.

Screencast: Buster.js Introdução (2:45)

profissionais :

• Usa o node.js, tão compatível com o Win / OS X / Linux
• Execute testes a partir de um navegador ou sem cabeça com o PhantomJS (em breve)
• Executar em vários clientes ao mesmo tempo
• Suporta teste NodeJS
• Não é necessário executar o servidor / clientes no computador de desenvolvimento (não é necessário o IE)
• Execute testes a partir de uma linha de comando (pode ser integrado ao ant / maven)
• Escreva testes no estilo xUnit ou BDD
• Suporta várias estruturas de teste JavaScript
• Adie os testes em vez de comentá-los
• SinonJS embutido
• Executar testes automaticamente ao salvar
• Proxies solicita vários domínios
• Possível personalizar:
  • Estenda-o para agrupar outras estruturas de teste (JsTestDriver embutido)
  • Suas próprias afirmações / refutações
  • Repórteres (xUnit XML, pontos tradicionais, especificação, toque, TeamCity e mais integrados)
  • Personalizar / substituir o HTML usado para executar os testes do navegador
• Integração TextMate e Emacs

Contras :

• Ainda na versão beta, pode ser de buggy
• Nenhum plugin para Eclipse / IntelliJ (ainda)
• Não agrupa resultados por os / browser / versão como TestSwarm *. No entanto, imprime o nome e a versão do navegador nos resultados do teste.
• Não há histórico de resultados de testes anteriores, como TestSwarm *
• Não funciona totalmente no Windows a partir de maio de 2014

* TestSwarm também é um servidor de Integração Contínua, enquanto você precisa de um servidor de IC separado para o Buster.js. No entanto, ele gera relatórios XML xUnit, portanto, deve ser fácil integrar-se ao Hudson , Bamboo ou outros servidores de CI.

TestSwarm

https://github.com/jquery/testswarm

O TestSwarm não está mais em desenvolvimento ativo, como declarado na página do GitHub. Eles recomendam Karma, browserstack-runner ou Intern.

Jasmim

Essa é uma estrutura orientada a comportamento (conforme indicado na citação abaixo) que pode interessar aos desenvolvedores familiarizados com Ruby ou Ruby on Rails. A sintaxe é baseada no RSpec que é usado para teste em projetos Rails.

As especificações do jasmim podem ser executadas a partir de uma página html (no modo qUnit) ou de um executor de teste (como Karma).

Jasmine é uma estrutura de desenvolvimento orientada a comportamento para testar seu código JavaScript. Não depende de nenhuma outra estrutura JavaScript. Não requer um DOM.

Se você tem experiência com essa estrutura de teste, contribua com mais informações :)

Página inicial do projeto: http://jasmine.github.io/

QUnit

O QUnit se concentra no teste de JavaScript no navegador, ao mesmo tempo em que oferece o máximo de conveniência possível ao desenvolvedor. Destaque do site:

QUnit é uma suíte de testes de unidade JavaScript poderosa e fácil de usar. É usado pelos projetos jQuery, jQuery UI e jQuery Mobile e é capaz de testar qualquer código JavaScript genérico

QUnit compartilha um pouco da história com o TestSwarm (acima):

O QUnit foi desenvolvido originalmente por John Resig como parte do jQuery. Em 2008, ele recebeu sua própria casa, nome e documentação da API, permitindo que outras pessoas o usassem também para testes de unidade. Na época, ainda dependia do jQuery. Uma reescrita em 2009 determinou que, agora o QUnit é executado de forma totalmente independente. Os métodos de asserção do QUnit seguem a especificação CommonJS Unit Testing, que foi até certo ponto influenciada pelo QUnit.

Página inicial do projeto: http://qunitjs.com/

Sinon

Outra ótima ferramenta é o sinon.js de Christian Johansen, autor do desenvolvimento de JavaScript orientado a testes . Melhor descrito por ele mesmo:

Espiões, stubs e zombarias de teste independentes para JavaScript. Nenhuma dependência funciona com qualquer estrutura de teste de unidade.

Estagiário

O site Intern oferece uma comparação direta de recursos com outras estruturas de teste nesta lista. Ele oferece mais recursos prontos para uso do que qualquer outro sistema de teste baseado em JavaScript.

JEST

Uma estrutura de teste nova, mas ainda muito poderosa. Permite testes baseados em instantâneos, o que aumenta a velocidade do teste e cria uma nova dinâmica em termos de teste

Confira uma de suas palestras: https://www.youtube.com/watch?v=cAKYQpTC7MA

Melhor ainda: Introdução

Dê uma olhada na estrutura de teste de unidade Dojo Object Harness (DOH), que é praticamente uma estrutura independente de estrutura para teste de unidade JavaScript e não possui nenhuma dependência do Dojo. Há uma descrição muito boa disso em testes de unidade de aplicativos da Web 2.0 usando o Dojo Objective Harness .

Se você deseja automatizar o teste da interface do usuário (um ponto dolorido para muitos desenvolvedores) - confira doh.robot (atualização temporária inativa : outro link http://dojotoolkit.org/reference-guide/util/dohrobot.html ) e dijit .robotx (desativação temporária) . O último foi projetado para um teste de aceitação. Atualizar:

Os artigos mencionados explicam como usá-los, como emular um usuário interagindo com sua interface do usuário usando o mouse e / ou teclado e como gravar uma sessão de teste, para que você possa "reproduzi-la" mais tarde automaticamente.

Chutzpah - Um corredor de teste de JavaScript

Criei um projeto de código aberto chamado Chutzpah, que é um corredor de teste para testes de unidade JavaScript. O Chutzpah permite executar testes de unidade JavaScript na linha de comando e de dentro do Visual Studio. Ele também suporta a execução no servidor de integração contínua TeamCity.

A seção JavaScript da entrada da Wikipedia, Lista de estruturas de teste de unidade , fornece uma lista de opções disponíveis. Indica se eles funcionam no lado do cliente, no servidor ou em ambos.

BusterJS

Há também o BusterJS de Christian Johansen, o autor do desenvolvimento de Javascript orientado a testes e o framework Sinon. Do site:

O Buster.JS é uma nova estrutura de teste de JavaScript. Ele faz o teste do navegador automatizando as execuções de teste em navegadores reais (pense em JsTestDriver), bem como no Node.js.

google-js-test:

Estrutura de teste de JavaScript lançada pelo Google: https://github.com/google/gjstest

• Tempo de inicialização e execução de teste extremamente rápido, sem a necessidade de executar um navegador.
• Saída limpa e legível no caso de testes aprovados e reprovados.
• Um executor de teste baseado em navegador que pode simplesmente ser atualizado sempre que o JS for alterado.
• Estilo e semântica que se assemelham ao Google Test for C ++.
• Uma estrutura de simulação integrada que requer um código padrão mínimo (por exemplo, não $tearDownou $verifyAll) com estilo e semântica baseada no Google C ++ Mocking Framework .

No momento, não há binários para Windows

Agora estamos usando o Qunit com Pavlov e JSTestDriver todos juntos. Essa abordagem funciona bem para nós.

QUnit

Pavlov , fonte

jsTestDriver , fonte

Você tem "roda no navegador real" como profissional, mas, na minha experiência, isso é um golpe porque é lento. Mas o que o torna valioso é a falta de emulação JS suficiente das alternativas que não são de navegador. Pode ser que, se o seu JS for suficientemente complexo, apenas um teste no navegador seja suficiente, mas há mais algumas opções a serem consideradas:

HtmlUnit : "Possui um bom suporte a JavaScript (que está em constante aprimoramento) e é capaz de funcionar mesmo com bibliotecas AJAX bastante complexas, simulando o Firefox ou o Internet Explorer, dependendo da configuração que você deseja usar." Se a emulação for boa o suficiente para o seu uso, será muito mais rápido do que dirigir um navegador.

Mas talvez o HtmlUnit tenha suporte JS suficientemente bom, mas você não gosta de Java? Então talvez:

Rapidez : Watir API em execução no JRuby apoiado por HtmlUnit.

ou similar

Schnell : outro invólucro JRuby de HtmlUnit.

Obviamente, se o HtmlUnit não for bom o suficiente e você precisar dirigir um navegador, considere o Watir dirigir seu JS .

A YUI também possui uma estrutura de teste . Este vídeo do Yahoo! O teatro é uma boa introdução, embora haja muitos princípios básicos sobre TDD na frente.

Essa estrutura é genérica e pode ser executada em qualquer biblioteca JavaScript ou JS.

Você também pode estar interessado na estrutura de teste de unidade que faz parte do qooxdoo , uma estrutura RIA de código aberto semelhante ao Dojo, ExtJS, etc., mas com uma cadeia de ferramentas bastante abrangente.

Experimente a versão online do testrunner . Dica: pressione a seta cinza no canto superior esquerdo (deve ficar mais óbvio). É um botão "play" que executa os testes selecionados.

Para descobrir mais sobre as classes JS que permitem definir seus testes de unidade, consulte o visualizador de API online .

Para testes automatizados de interface do usuário (com base no Selenium RC), confira o projeto Simulator .

Você deve ter um olhar para env.js . Veja meu blog para um exemplo de como escrever testes de unidade com env.js.

Adicionamos a integração do JUnit ao nosso gerador de código Java-Javascript ST-JS ( http://st-js.org ). A estrutura gera o Javascript correspondente para o código testado e os testes de unidade e envia o código para diferentes navegadores.

Não há necessidade de um servidor separado, pois o executor de teste da unidade abre a porta http necessária (e a fecha após a conclusão dos testes). A estrutura manipula o rastreamento de pilha Java para que as declarações com falha sejam exibidas corretamente pelo plug-in JUnit Eclipse. Aqui está um exemplo simples com jQuery e Mockjax:

@RunWith(STJSTestDriverRunner.class)
@HTMLFixture("<div id='fortune'></div>")

@Scripts({ "classpath://jquery.js",
       "classpath://jquery.mockjax.js", "classpath://json2.js" })
public class MockjaxExampleTest {
  @Test
  public void myTest() {
    $.ajaxSetup($map("async", false));
    $.mockjax(new MockjaxOptions() {
      {
        url = "/restful/fortune";
        responseText = new Fortune() {
          {
            status = "success";
            fortune = "Are you a turtle?";
          }
        };
      }
    });

    $.getJSON("/restful/fortune", null, new Callback3<Fortune, String, JQueryXHR>() {
      @Override
      public void $invoke(Fortune response, String p2, JQueryXHR p3) {
        if (response.status.equals("success")) {
          $("#fortune").html("Your fortune is: " + response.fortune);
        } else {
          $("#fortune").html("Things do not look good, no fortune was told");
        }

      }
    });
    assertEquals("Your fortune is: Are you a turtle?", $("#fortune").html());
  }

  private static class Fortune {
    public String status;
    public String fortune;
  }
}

O MochiKit possui uma estrutura de teste chamada SimpleTest que parece ter captado. Aqui está um post do autor original .