Teste de unidade automatizado com JavaScript

StackOverflow https://stackoverflow.com/questions/96066

Pergunta

Eu estou tentando incorporar alguns testes de unidade JavaScript no meu processo de compilação automatizada. Atualmente JsUnit funciona bem com JUnit, mas parece ser abandonware e carece de um bom suporte para AJAX, a depuração, e tempos de espera.

Alguém já teve alguma automatização sorte (com ANT) uma unidade de teste biblioteca, como teste de YUI, QUnit do JQuery, ou jQUnit ( http://code.google.com/p/jqunit/ )?

Nota:. Eu uso um costume construído biblioteca AJAX, então o problema com DOH do Dojo é que ele requer que você use a sua própria função AJAX chamadas e manipuladores de eventos para trabalhar com qualquer teste de unidade AJAX

Foi útil?

Solução

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

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

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

        function() { callback(result); }, 
        300  // some fake latency

      );
    }

E sim, JsUnit fazer timeouts punho: Simulando Tempo em jsUnit Testes

Outras dicas

Eu estou prestes a começar a fazer Javascript TDD em um novo projeto que estou trabalhando. Meu plano atual é usar QUnit para fazer o teste de unidade. Ao desenvolver os testes podem ser executados simplesmente atualizar a página de teste em um navegador.

Para a integração contínua (e garantir os testes executados em todos os navegadores), vou usar selênio para carregar automaticamente o equipamento de teste em cada navegador, e ler o resultado. Estes testes serão executados em cada checkin ao controle de origem.

Eu também vou usar JSCoverage para obter análise de cobertura de código dos testes. Isso também será automatizado com Selenium.

Atualmente estou no meio de fazer essa configuração. Eu vou atualizar esta resposta com detalhes mais exatos, uma vez que tenho a configuração martelada.

Ferramentas de teste:

Im um grande fã de js-test-driver de

Ele funciona bem em um ambiente de CI e é capaz de capturar os navegadores reais para testes de cross-browser.

Recentemente li um artigo de Bruno usando JsUnit e criando um quadro JsMock em cima disso ... muito interessante. Estou pensando em usar seu trabalho para começar a unidade testar meu código Javascript.

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

Estou de acordo em que JsUnit é uma espécie de morrer na videira. Acabamos de terminar-se substituí-lo com YUI teste.

Semelhante ao exemplo usando QUnit, estamos executando os testes usando Selenium. Estamos executando este teste de forma independente a partir de nossos outros testes de selênio, simplesmente porque ele não tem as dependências que os testes de regressão UI normais têm (por exemplo, a implantação do aplicativo para um servidor).

Para começar, temos um arquivo de base javascript que está incluído em todos os nossos arquivos de teste HTML. Esta configuração se a instância YUI alças, o corredor de teste, o objeto YUI.Test.Suite bem como a Test.Case. Tem um métodos que podem ser acessados ??através de selênio para executar o conjunto de testes, verificar para ver se o corredor de teste ainda está em execução (resultados não estão disponíveis até depois de pronto), e obter os resultados do teste (escolhemos 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);
}

Como para o lado de selênio das coisas, foi utilizado um teste com parâmetros. Corremos nossos testes em IE e Firefox no método de dados, analisar os resultados do teste em uma lista de matrizes objeto com cada matriz contendo o nome do navegador, o nome do arquivo de teste, o nome do teste, o resultado (aprovação, reprovação ou ignorar) ea mensagem.

O teste real apenas afirma o resultado do teste. Se não é igual a "passar", então ele não passar no teste com a mensagem devolvida a partir do resultado YUI teste. 

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

    List<Object[]> testResults = new ArrayList<Object[]>();

    pageNames = new ArrayList<String>();
    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<Object[]> runJSTestsInBrowser(Browser aBrowser) {
    String yui_test_codebase = "file:///c://myapppath/yui/tests/";
    String browser_bot = "this.browserbot.getCurrentWindow()"
    List<Object[]> testResults = new ArrayList<Object[]>();
    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 isso é útil.

Há um novo projecto que permite executar QUnit testes em um ambiente Java (como formigas), assim você pode integrar plenamente o seu conjunto de testes do lado do cliente com seus outros testes de unidade.

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

Eu usei-o para plugins jQuery teste de unidade, objx código, costume OO JavaScript e funciona para tudo sem modificação.

O projeto que estou trabalhando sobre os usos Js-Test-Driver hospedagem Jasmine no Chrome 10 com Jasmine-JSTD-Adapter inclusive fazendo uso de testes de cobertura de código incluído no JS-Test-driver. Embora existam alguns problemas cada vez que mudar ou atualizar navegadores no ambiente CI os testes de jasmim está executando bastante bem com apenas pequenas questões com testes ansynchronous, mas tanto quanto eu estou ciente destes pode ser contornado usando Jasmine relógio, mas eu não tive a chance de patch-los ainda.

Eu já publicou um pouco biblioteca para verificar testes JavaScript dependente do navegador sem ter que usar um navegador . É um node.js módulo 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 os olhares de automação como: 

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();
        }
    });
});

});

Eu olhei em sua data de perguntas e volta, em seguida, houve algumas boas JS teste lib / quadro. Hoje você pode encontrar muito mais e no foco diferente, como TDD, BDD, assetion e com / sem apoio corredores.

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

Outra estrutura de testes de JS que pode ser executado com Ant é CrossCheck . Há um exemplo de execução CrossCheck via Ant no arquivo de construção para o projeto.

tentativas CrossCheck, com sucesso limitado, para emular um navegador, incluindo implementações de estilo de simulação de XMLHttpRequest e tempo limite / intervalo.

Não atualmente lidar com carregamento javascript a partir de uma página web, no entanto. Você tem que especificar os arquivos javascript que você quer de carga e teste. Se você manter todas as suas JS separado do seu HTML, ele pode trabalhar para você.

Eu escrevi uma tarefa Ant que usa Fantasma JS , um navegador sem cabeçalho webkit, para executar QUnit html arquivos de teste dentro de um processo de construção Ant. Ele também pode deixar a compilação se todos os testes falham.

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

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

JavaScript ferramentas de teste de unidade para TDD

Eu, pessoalmente, prefiro https://code.google.com/p/js-test-driver/

Licenciado em: CC-BY-SA com atribuição
Não afiliado a StackOverflow
scroll top