Estrutura de teste vs karma Jasmine, Mocha, QUnit [fechado]

Algumas perguntas:

• Como o Karma e a estrutura de teste X (Jasmine, Mocha, QUnit) se relacionam?
• Qual é a estrutura equivalente no mundo Java? Suponho Jasmine, Mocha, QUnit igual a jUnit / TestNG. E o Karma?
• Posso executar a estrutura de teste X (por exemplo, Jasmine) sem Karma?
• O Karma é para teste de unidade ou integração / teste e2e? Esta referência mostra é para teste de unidade, no entanto, isto é para teste e2e.

Karma é um corredor de teste do navegador.

A idéia é que os navegadores não tenham um conceito nativo de carregar arquivos de testes, executá-los e reportar resultados. O que o karma faz é (aproximadamente):

• iniciando um pequeno servidor web para servir arquivos javascript "do lado do cliente" a serem testados (1)
• também serve os arquivos javascript "do lado do cliente" nos testes (ou Especificações, como costuma ser chamado) (2)
• exibir uma página da web personalizada que executará o código javascript para os testes (3)
• inicie um navegador para carregar esta página (4)
• relate os resultados do teste ao servidor (5)
• O karma pode relatar os resultados novamente em arquivos de texto, console, qualquer coisa que seu servidor de CI goste, etc.

Olhando para cada parte:

(1) Esses arquivos serão seus arquivos js reais; você dirá ao karma como carregá-los. Se você usar requirejs, há um plug-in de karma e é necessária alguma configuração.

(2) Esses testes podem ser escritos em uma variedade de estruturas de teste Javascript (Jasmine, QUnit, Mocha); esse é o código JS que é executado no navegador.

(3) A página da Web personalizada será um pouco diferente para cada estrutura de teste; é por isso que o karma possui plugins para diferentes estruturas.

(4) O Karma pode iniciar a página em muitos navegadores (FF, Chrome ou navegadores sem cabeça, como o PhantomJs.)

(5) Relatar o karma é novamente dependente da estrutura e é tratado com os plugins do karma.

Então, para responder às suas perguntas:

• em Java, a maioria das pessoas usa o JUnit, que é uma estrutura para escrever testes e executá-los, mas não tem o problema de diferenciar o ambiente no qual os testes são executados e aquele no qual os relatórios de teste são agregados; O karma seria a peça que faltava entre um JUnit Suite e um JUnit TestRunner
• Sim, você pode fazer tudo o que o karma faz "manualmente" - escolha uma estrutura (jasmim, qunit, mocha) e siga as instruções. A vantagem do karma é que ele fornece uma solução pronta para uso, se você estiver em uma configuração padrão.
• O karma pode ser usado para testes de unidade (com jasmim / qunit / qualquer) e testes de integração (que usarão outra API, como webdriver, para dirigir o navegador)

Uma maneira mais curta de entender a diferença:

As pessoas que testam com Jasmine / Mocha comum provavelmente estão executando todo o código com a máquina virtual Node.

Adicionar Karma à mistura (além da estrutura de sua escolha existente) executará seu conjunto de testes com o mecanismo de outros navegadores.

Ao fazer isso, você obtém os pequenos extras que obtém em um ambiente de navegador. Será mais fácil testar o código relacionado ao DOM, mas você também abrirá mão dos recursos extras fornecidos pelo mecanismo do Node (como sistema de arquivos / acesso ao shell)

A tese do sujeito que projetou o Karma foi muito informativa ao descrever as soluções existentes e compará-las, e, é claro, ao descrever o próprio Karma

https://github.com/karma-runner/karma/blob/master/thesis.pdf

Resumo: Karma é um corredor de teste. Pode ser usado por QUnit, Jasmine, Mocha, ... O karma tem vantagens para outros executores de teste para melhorar seu ciclo de desenvolvimento de TDD / BDD. Ele "assiste" os arquivos; portanto, quando você salva uma alteração, o Karma executa testes e relatórios instantaneamente, sem alternar o contexto para o Navegador da Web para executar o teste.

Em suma, talvez a pergunta deva ser Karma AND Jasmine ou Mocha ou QUnit?