Mocha, um novo sabor em testes unitários de Javascript
Mocha pode ser definido como um framework de testes rico em características que pode ser implementado em nodejs ou por meio de um navegador. Mocha executa os testes em serie permitindo relatórios flexíveis e exatos, fazendo com que o código passado por testes seja ótimo no momento de estar em produção. Porém, se pode resumir a definição de mocha em três palavras “simples”, “flexível” y “divertido”
Características ou Atributos
- Suporte para diferentes navegadores
- Relatórios de cobertura de código
- Uso de qualquer biblioteca de afirmações
- Javascript api para executar testes.
- Suporte de Debugger para nodejs
Só se mencionam cinco atributos mas existem mais que parece que vão aumentando devido a mocha estar crescendo a cada dia no campo de testes unitários.
Instalação
A instalação para explicar os exemplos se fará da maneira mais simples por meio de npm(gestionador de pacotes de nodejs), mas para poder realizar esta operação necessitamos ter instalado nodejs e por meio deste link http://nodejs.org/download/ se pode baixar e tem suporte para muitos sistemas operativos.
npm install -g mocha (por meio da linha de comandos)
Uma vez instalado o pacote podem ser feitos testes unitários, mas antes disso se devem dar conceitos com seus respectivos exemplos para entendê-los de uma maneira melhor.
Assertions ou Afirmações
Mocha permite que você utilize qualquer biblioteca de afirmações como por exemplo should.js, expect.js, chai e better-assert o que faz com que seja mais flexível aos gostos dos programadores por uma biblioteca em particular.
Por meio da linha de comandos executamos as seguintes sentenças mkdir PU_Mocha use seu editor favorito. No meu caso uso “gvim” e criou o arquivo chamado “teste.js”
Exemplo:
var assert = require(“assert”);
descreve(“Cadeias”,function(){
descreve(“subcadeias”,function(){
it(‘deveria retornar uma sub cadeias’,function(){
assert.equal(“Bello”,”Panama e Belo”.substring(10,15));
})
})
});
Explicação:
Uma vez escrito o teste unitario executamos o seguinte comando “mocha teste.js” e se apresenta uma saída como na seguinte imagem.
A primeira linha de código chama a biblioteca “assert” para ter uma variável e poder realizar as afirmações.
A segunda linha descreve um módulo chamado “Cadeias” isto significa que dentro dele se manipulam cadeias de caracteres.
A terceira linha descreve um submódulo chamado “subcadeias” para se referir a que os testes unitarios dentro dele serão com respeito às mesmas.
A quarta linha descreve o nome do teste unitario.
A quinta linha verifica se a subcadeia se encontra dentro da cadeia.
Para o exemplo seguinte utilizaremos uma biblioteca de afirmações que neste caso é a grande e famosa “should.js” e se instalará a seguinte forma npm install should.
Exemplo:
var should = require(“should”);
descreve(“Cadeias”,function(){
descreve(“subcadeias”,function(){
it(‘usando a biblioteca should’,function(){
‘Panama e Belo’.substring(10,15).should.equal(‘Belo’);
});
});
});
Explicação:
A primeira linha inclui a biblioteca should, que é com a executaremos o teste unitário.
A quinta linha é onde se executa o teste da subcadeia mediante a variável “should”
Este exemplo mostra o simples que é poder usar esta grande biblioteca.
Organizações
As organizações ou setups nos permitem ter nossos testes unitários mais claros no momento de criar variáveis e segmentar nosso código, ademais é mais legível no momento em que outro programador veja nossos testes unitários.
Exemplo:
descreve(‘calculadora’, function(){
var a,b;
beforeEach(function(){
a = 4;
b = 2;
});
descreve(‘operacoes básicas’ ‘, function(){
it(‘soma’,function(){
assert.equal(a + b,6);
});
it(‘subtracao’,function(){
assert.equal(a – b,2);
});
});
});
Explicação:
O exemplo mostra que as variáveis “a” e “b” adquirem seus respectivos valores cada vez que se executa um teste unitário e não há necessidade de criar varáveis por cada teste . É uma maneira mais simples para poder realizar o trabalho.
Testes Exclusivos
A característica de exclusividade pode ser dada a um módulo ou a um teste específico para poder n enfocar nossos testes unitários em um código em específico. É um atributo que facilita fazer testes de nosso código javascript. Para esta seção se apresentam dois exemplos que ampliarão a teoria descrita.
Exemplo:
descreve(‘Calculadora’,function(){
var a,b;
beforeEach(function(){
a = 4;
b = 2;
});
descreve(‘operacoes basicas 1’,function(){
it(‘soma’,function(){
assert.equal(a + b,6);
});
it(‘subtracao’,function(){
assert.equal(a – b,2);
});
});
descreve.only(‘operacoes basicas 2’,function(){
it(‘multiplicacao’,function(){
assert.equal(a * b,8);
});
it(‘divisao’, function(){
assert.equal(a / b, 2);
});
});
});
Explicação:
A palavra reservada “only” é a que nos permite só executar o modulo chamado “operações básicas 2” o que quer dizer que só se executam dois testes unitarios.
Exemplo:
descreve(‘calculadora’,function(){
descreve(‘operacoes especiais’,function(){
it(‘raiz quadrada’,function(){
assert.equal(Math.sqrt(16),4);
});
it.only(‘exponentes’,function(){
assert.equal(Math.pow(4,2),16);
});
});
});
Explicação:
Dentro do módulo chamado “operações especiais” somente se executa o teste unitário de “exponentes” porque têm a palavra reservada “only”. Algo muito bom dentro deste framework.
Testes não Exclusivos
Os testes não exclusivos nos permitem ignorar módulos ou testes unitários que não têm alta prioridade no momento de executar os testes Com os dois exemplos seguintes se mostra o descrito na teoria.
Exemplo:
descreve(‘Gestao de cadeias’,function(){
describe.skip(‘subcadeias’,function(){
it(‘teste de subcadeia’,function(){
assert.equal(“Bela”,”Panama e Bela”.substring(10,15));
});
});
descreve(‘contador’,function(){
it(‘quantidade de caracteres’,function(){
assert.equal(“Panama e Bela”.length,15);
});
});
});
Explicação:
Ao executar este código na consola aparece uma mensagem de que existem testes unitarios pendentes, graças à palavra reservada “skip” no módulo chamado “subcadeias”.
Exemplo:
descreve(‘Gestao de cadeias’,function(){
descreve(‘subcadeias’,function(){
it(‘teste de subcadeia’,function(){
assert.equal(“Bela”,”Panama e Bela”.substring(10,15));
});
});
descreve(‘contador’,function(){
it.skip(‘quantidade de caracteres’,function(){
assert.equal(“Panama e Bela”.length,15);
});
});
});
Explicação:
Com o exemplo sempre ficará um teste unitário pendente que é a chamada “quantidade de caracteres” a qual tem a palavra reservada “skip”.
Com o pouco que se pode ver de “Mocha” se pode chegar à conclusão de que seria uma boa ferramenta para implementá-la em nossos projetos pessoais como também em nossos projetos para clientes, além de ter uma classe de facilidades para os gostos de muitos programadores. Na minha opinião pessoal este framework tem um bom futuro por diante e é só esperar o que de novo nos trará o grande “Mocha”. Só falta dizer “Happy Testing”.
Fonte: http://www.criarweb.com/artigos/mocha-framework-javascript.html