Teste de Unidade Automatizado com JavaScript

Estou tentando incorporar alguns testes de unidade de JavaScript em meu processo de criação automatizado. Atualmente, o JSUnit funciona bem com o JUnit, mas parece ser abandonado e falta um bom suporte para AJAX, depuração e tempos limite.

Alguém já teve alguma sorte de automatizar (com ANT) uma biblioteca de testes de unidade, como o teste YUI, o QUnit da jQuery ou o jQUnit ( http://code.google.com/p/jqunit/ )?

Nota: Eu uso uma biblioteca AJAX customizada, então o problema com o DOH do Dojo é que ele requer que você use suas próprias chamadas de função AJAX e manipuladores de eventos para trabalhar com qualquer teste de unidade AJAX.

0
adicionado editado
Visualizações: 4
Pergunta relacionada: JavaScript melhor"> stackoverflow .com/questions/300855/& hellip;
adicionado o autor Jacques Bosch, fonte

14 Respostas

Recentemente li um artigo de Bruno usando o JsUnit e criando um framework JsMock além disso ... muito interessante. Estou pensando em usar o seu trabalho para iniciar a unidade testando meu código Javascript.

Mock Javascript ou como teste de unidade Javascript fora do ambiente do navegador

0
adicionado

Há muitos frameworks de teste de unidade JavaScript lá fora (jsUnit, scriptaculous, ...), mas jsUnit é o único que eu sei que pode ser usado com uma compilação automatizada.

Se você está fazendo um teste de unidade 'verdadeiro' você não deve precisar de suporte AJAX. Por exemplo, se você estiver usando uma estrutura ajax RPC, como DWR, poderá escrever facilmente uma função simulada:

   function mockFunction(someArg, callback) {
      var result = ...;//some treatments   
      setTimeout(
function() { callback(result); }, 300 //some fake latency
); }

And yes, JsUnit do handle timeouts : Simulating Time in jsUnit Tests

0
adicionado

Look into YUITest

0
adicionado

Publiquei uma pequena biblioteca para verificar testes JavaScript dependentes do navegador sem ter que usar um navegador. É um módulo node.js que usa zombie.js para carregar a página de teste e inspecionar os resultados. Eu escrevi sobre isso no meu blog . Aqui está o que a automação se parece:

var browsertest = require('../browsertest.js').browsertest;

describe('browser tests', function() {

it('should properly report the result of a mocha test page', function (done) {
    browsertest({
        url: "file:///home/liam/work/browser-js-testing/tests.html",
        callback: function() { 
            done();
        }
    });
});

});
0
adicionado

Eu olhei na sua data de perguntas e, em seguida, houve alguns bons JS testing lib/framework. Hoje você pode encontrar muito mais e com foco diferente, como TDD, BDD, Assição e com/sem suporte a corredores.

Existem muitos jogadores neste jogo como Mocha, Chai, QUnit, Jasmine, etc ... Você pode encontrar mais algumas informações em este blog sobre testes em JS/Mobile/web ...

0
adicionado

Outro framework de testes JS que pode ser executado com o Ant é CrossCheck . Há um exemplo de execução do CrossCheck via Ant no arquivo de compilação do projeto.

CrossCheck tenta, com sucesso limitado, emular um navegador, incluindo implementações em estilo mock de XMLHttpRequest e timeout/interval.

Atualmente, ele não processa o carregamento de JavaScript de uma página da Web. Você tem que especificar os arquivos JavaScript que você deseja carregar e testar. Se você mantiver todo o seu JS separado do seu HTML, isso pode funcionar para você.

0
adicionado

Estou prestes a começar a fazer o Javascript TDD em um novo projeto em que estou trabalhando. Meu plano atual é usar qunit para fazer o teste de unidade. Enquanto o desenvolvimento dos testes pode ser executado simplesmente atualizando a página de teste em um navegador.

Para integração contínua (e garantir que os testes sejam executados em todos os navegadores), usarei Selenium para carregar automaticamente o chicote de teste em cada navegador e leia o resultado. Esses testes serão executados em cada check-in para o controle de origem.

Também irei usar JSCoverage para obter uma análise de cobertura de código dos testes. Isso também será automatizado com o Selenium.

Eu estou atualmente no meio de configurar isso. Eu atualizarei esta resposta com detalhes mais precisos uma vez que eu tenha a configuração elaborada.


Ferramentas de teste:

0
adicionado
sim, por favor, compartilhe. obrigado
adicionado o autor melaos, fonte
Eu consegui configurar isso, mas usando tecnologias ligeiramente diferentes. Eu usei JS Test Driver para executar os testes de unidade em cada navegador (em vez de Selenium), usando o adaptador QUnit ( code.google.com/p/js-test-driver/wiki/QUnitAdapter ). Outro no meu empregador atual eu estou usando o framework de teste Jasmine, e executando os testes no Jasmine Node ( github.com/mhevery/jasmine-node ) que evita o
adicionado o autor Karl, fonte
praticamente o melhor uso de selênio. cara, eu perdi muito tempo com essa coisa. resmungar resmungar ....
adicionado o autor the0ther, fonte
Você já conseguiu isso? Como foi?
adicionado o autor El Yobo, fonte
Oi @ Karl.Encontro também qunit como uma ferramenta útil, mas não sei exatamente o que testar. Eu tenho uma lógica de jogo escrita em JavaScript com combinações, animações. Você pode pls me ajudar com algumas informações? Obrigado.
adicionado o autor Anahit Ghazaryan, fonte

Im a big fan of js-test-driver

Ele funciona bem em um ambiente de IC e é capaz de capturar navegadores reais para testes entre navegadores.

0
adicionado
Eu gosto disso por causa da integração do CI, mas acho que o melhor é que ele funciona com o YUITest e o QUnit!
adicionado o autor AutomatedTester, fonte

Estou de acordo que jsunit está morrendo na videira. Acabamos de substituí-lo pelo YUI Test.

Semelhante ao exemplo usando o qUnit, estamos executando os testes usando o Selenium. Estamos executando este teste independentemente de nossos outros testes de selênio, simplesmente porque ele não tem as dependências que os testes normais de regressão da IU têm (por exemplo, implantar o aplicativo em um servidor).

Para começar, temos um arquivo JavaScript básico que está incluído em todos os nossos arquivos html de teste. Isso lida com a configuração da instância YUI, do executor de testes, do objeto YUI.Test.Suite e do Test.Case. Ele possui um método que pode ser acessado via Selenium para executar o conjunto de testes, verificar se o executor de testes ainda está em execução (os resultados não estão disponíveis até que seja feito) e obter os resultados do teste (escolhemos o formato JSON)

var yui_instance; //the YUI instance
var runner;  //The YAHOO.Test.Runner
var Assert; //an instance of YAHOO.Test.Assert to save coding
var testSuite; //The YAHOO.Test.Suite that will get run.

/**
 * Sets the required value for the name property on the given template, creates
 * and returns a new YUI Test.Case object.
 * 
 * @param template the template object containing all of the tests
 */
function setupTestCase(template) {
    template.name = "jsTestCase";
    var test_case = new yui_instance.Test.Case(template);
    return test_case;
}

/**
 * Sets up the test suite with a single test case using the given 
 * template.
 * 
 * @param template the template object containing all of the tests
 */
function setupTestSuite(template) {
    var test_case = setupTestCase(template);
    testSuite = new yui_instance.Test.Suite("Bond JS Test Suite");
    testSuite.add(test_case);
}

/**
 * Runs the YAHOO.Test.Suite
 */
function runTestSuite() {
    runner = yui_instance.Test.Runner;
    Assert = yui_instance.Assert;

    runner.clear();
    runner.add(testSuite);
    runner.run();
}

/**
 * Used to see if the YAHOO.Test.Runner is still running.  The
 * test results are not available until it is done running.
 */
function isRunning() {
    return runner.isRunning();
}

/**
 * Gets the results from the YAHOO.Test.Runner
 */
function getTestResults() {
    return runner.getResults(yui_instance.Test.Format.JSON);
}

Quanto ao lado do selênio, usamos um teste parametrizado. Executamos nossos testes no IE e no FireFox no método de dados, analisando os resultados do teste em uma lista de matrizes de objetos com cada matriz contendo o nome do navegador, o nome do arquivo de teste, o nome do teste, o resultado (passar, falhar ou ignorar) e a mensagem.

O teste real apenas confirma o resultado do teste. Se não for igual a "passar", ele falhará no teste com a mensagem retornada do resultado do Teste YUI.

    @Parameters
public static List data() throws Exception {
    yui_test_codebase = "file:///c://myapppath/yui/tests";

    List testResults = new ArrayList(); pageNames = new ArrayList(); pageNames.add("yuiTest1.html"); pageNames.add("yuiTest2.html"); testResults.addAll(runJSTestsInBrowser(IE_NOPROXY)); testResults.addAll(runJSTestsInBrowser(FIREFOX)); return testResults; } /** * Creates a selenium instance for the given browser, and runs each * YUI Test page. * * @param aBrowser * @return */ private static List runJSTestsInBrowser(Browser aBrowser) { String yui_test_codebase = "file:///c://myapppath/yui/tests/"; String browser_bot = "this.browserbot.getCurrentWindow()" List testResults = new ArrayList(); selenium = new DefaultSelenium(APPLICATION_SERVER, REMOTE_CONTROL_PORT, aBrowser.getCommand(), yui_test_codebase); try { selenium.start(); /* * Run the test here */ for (String page_name : pageNames) { selenium.open(yui_test_codebase + page_name); //Wait for the YAHOO instance to be available selenium.waitForCondition(browser_bot + ".yui_instance != undefined", "10000"); selenium.getEval("dom=runYUITestSuite(" + browser_bot + ")"); //Output from the tests is not available until //the YAHOO.Test.Runner is done running the suite selenium.waitForCondition("!" + browser_bot + ".isRunning()", "10000"); String output = selenium.getEval("dom=getYUITestResults(" + browser_bot + ")"); JSONObject results = JSONObject.fromObject(output); JSONObject test_case = results.getJSONObject("jsTestCase"); JSONArray testCasePropertyNames = test_case.names(); Iterator itr = testCasePropertyNames.iterator(); /* * From the output, build an array with the following: * Test file * Test name * status (result) * message */ while(itr.hasNext()) { String name = (String)itr.next(); if(name.startsWith("test")) { JSONObject testResult = test_case.getJSONObject(name); String test_name = testResult.getString("name"); String test_result = testResult.getString("result"); String test_message = testResult.getString("message"); Object[] testResultObject = {aBrowser.getCommand(), page_name, test_name, test_result, test_message}; testResults.add(testResultObject); } } } } finally { //if an exception is thrown, this will guarantee that the selenium instance //is shut down properly selenium.stop(); selenium = null; } return testResults; } /** * Inspects each test result and fails if the testResult was not "pass" */ @Test public void inspectTestResults() { if(!this.testResult.equalsIgnoreCase("pass")) { fail(String.format(MESSAGE_FORMAT, this.browser, this.pageName, this.testName, this.message)); } } 

Espero que isto seja útil.

0
adicionado

Eu apenas consegui que o Hudson CI rodasse JasmineBDD (sem cabeça), em menos para teste de unidade de JavaScript puro.

(Hudson executando Java via shell, executando Envjs, executando JasmineBDD.)

Eu ainda não consegui tocar com uma grande biblioteca, como protótipo.

0
adicionado

Há um novo projeto que permite executar testes qunit em um ambiente Java (como o formiga) para que você possa integrar totalmente seu conjunto de testes do lado do cliente com seus outros testes de unidade.

http://qunit-test-runner.googlecode.com

Eu usei isso para testar jQuery plugins, objx código, personalizado OO JavaScript e funciona para tudo sem modificação.

0
adicionado

O projeto no qual estou trabalhando usa o Js-Test-Driver que hospeda Adaptador Jasmine-JSTD incluindo o uso de Cobertura de código testes incluídos no JS-Test-Driver. Embora haja alguns problemas sempre que alteramos ou atualizamos os navegadores no ambiente de IC , os testes de jasmim estão sendo executados muito bem com apenas pequenos problemas com testes ansynchronous, mas tanto quanto eu sei, estes podem ser contornados usando Jasmine Clock, mas eu não tive a chance de corrigi-los ainda.

0
adicionado

Escrevi uma tarefa do Ant que usa o Phantom JS , um navegador sem webkit, para executar arquivos de teste QUnit html em uma Ant processo de construção. Também pode falhar a compilação se algum teste falhar.

https://github.com/philmander/ant-jstestrunner

0
adicionado

Esta é uma boa avaliação de várias ferramentas de teste.

Ferramentas de teste de unidade JavaScript para TDD

I personally prefer https://code.google.com/p/js-test-driver/

0
adicionado