Como usar o uvu: um executor de teste rápido e leve

uvu (curto para velocidade final, desencadeada) é considerado um dos executores de teste mais rápidos e leves para Node.js e navegadores. Seus principais recursos incluem a execução individual de arquivos de teste, suporte a testes assíncronos, suporte a módulos ES nativos, compatibilidade com navegadores, tamanho leve excepcional, API familiar e desempenho notável. Esta postagem do blog cobrirá o uso de uvu, sua comparação com duas outras bibliotecas populares de execução de teste chamadas Jest e AVA , e por que e quando usá-lo para teste.

Por que usar uvu?

Em primeiro lugar, o uvu suporta teste assíncrono, que é uma das vantagens comuns que algumas bibliotecas de teste suportam. Ele ajuda a determinar se o código que está sendo testado concluiu o processo de teste antes de avançar para o próximo teste. O objetivo principal de uma função assíncrona (assíncrona) é apenas esclarecer a sintaxe que é obrigatória para consumir APIs baseadas em promessa. No teste assíncrono, um método será usado como callback ou promessa que determinará a conclusão de um processo de teste.

Outro recurso principal é a compatibilidade do navegador. No início, era um problema que o uvu não era compatível com os navegadores, mas isso foi resolvido executando uma pequena modificação no arquivo do processo. Você pode encontrar a discussão sobre a resolução do problema aqui . Portanto, mesmo se você estiver tendo algum tipo de problema com a compatibilidade do navegador, pode verificar este link para uma melhor compreensão e resolver o seu problema.

Usando uvu

Usar uvu é simples e funciona assim:

//tests/demo.js
//Fonte: https://github.com/lukeed/uvu importar {teste} de'uvu';
import * como assert from'uvu/assert'; test ('Math.sqrt ()', ()=> { assert.is (Math.sqrt (4), 2); assert.is (Math.sqrt (144), 12); assert.is (Math.sqrt (2), Math.SQRT2);
}); teste ('JSON', ()=> { const input={ foo:'olá', bar:'mundo' }; saída const=JSON.stringify (entrada); assert.snapshot (output, `{"foo":"hello","bar":"world"}`); assert.equal (JSON.parse (saída), entrada,'corresponde ao original');
}); test.run (); 

Agora o que você precisa fazer é apenas executar este arquivo de teste:

 # via `uvu` cli, para todos os arquivos`/tests/** `
testes $ uvu-r esm # via `node` diretamente, para isolamento de arquivo
$ node-r esm tests/demo.js 

O ponto a ser observado sobre as linhas de comando acima é que –r esm é especificado apenas para módulos Node.js legados, uma vez que os módulos Ecmascript (ES) são depositados nas versões Node.js> 12.x. Por padrão, os arquivos .js e .cjs são tratados como Common.js e as extensões de arquivo .mjs são apenas aquelas que seriam servidas como Módulos Ecmascript (ESM).

O exemplo acima pode ser considerado o método mais simples por meio do qual o Node.js carregará os módulos ES e concederá a eles a importação de qualquer módulo quando necessário. Além disso, você pode carregar módulos de algumas outras maneiras que são mostradas abaixo.

Existem também outras maneiras pelas quais o Node.js carregará os módulos ES. Esses métodos incluem procedimentos de tipo, módulo e pacote esm. Aqui estão os guias completos desses métodos:

• pacote esm https://github.com/lukeed/uvu/tree/master/examples/esm.loader
• módulo de tipo https://github.com/lukeed/uvu/tree/master/examples/esm.dual

Módulo uvu principal

O módulo uvu principal ajudará em relação aos testes ou trajes de teste (série de testes individuais relacionados a uma determinada funcionalidade no código) que são necessários para todos os testes uvu. Os usuários têm a opção disponível aqui de escolher uvu.test ou uvu.suite . Por meio do uvu.suite , pode-se obter inúmeras vantagens adicionais, como testar vários arquivos ao mesmo tempo, enquanto se deve escolher uvu.test se estiver pensando em testar apenas um único arquivo (tecnicamente uvu.test é um conjunto de testes sem nome).

uvu.suite (nome: string, contexto?: T)

Você pode ter quantas suítes desejar no mesmo arquivo, mas é necessário chamar as suítes run para cada suíte a ser adicionada à fila do uvu. Isso apenas retorna uma suíte junto com a criação de uma nova suíte. O nome aqui corresponde ao nome do conjunto e é do tipo string. Isso combinará todas as saídas do console e colocará o sufixo no nome de qualquer teste que falhar. O contexto da suíte tem um objeto vazio como valor padrão e é de qualquer tipo. Isso será passado para cada bloco de teste e gancho dentro da suíte.

uvu.test (nome: string, callback: função)

Se houver a necessidade de testar apenas um arquivo, você poderá importar este uvu.test . O nome aqui obviamente denota o nome do teste e é do tipo string e o retorno de chamada aqui consiste no código de teste e é do tipo promise ou function . O retorno de chamada pode ser assíncrono e retornar valores que, embora abandonados.

 importar {suite} de'uvu';
import * como assert from'uvu/assert';
importar * como datas de'../src/dates'; const Now=suite ('Date.now ()'); let _Date;
Now.before (()=> { deixe contar=0; _Date=global.Date; global.Date={agora: ()=> 100 + contagem ++};
}); Now.after (()=> { global.Date=_Date;
}); //isto não é executado (pular)
Now.skip ('deve ser uma função', ()=> { assert.type (Date.now,'função');
}); //isto não é executado (apenas)
Agora ('deve retornar um número', ()=> { assert.type (Date.now (),'número');
}); //isto é executado (apenas)
Now.only ('deve progredir com o tempo', ()=> { assert.is (Date.now (), 100); assert.is (Date.now (), 101); assert.is (Date.now (), 102);
}); Now.run (); 

 ~>"ava"levou 594 ms (???)
~>"jest"levou 962 ms (356 ms)
~>"mocha"levou 209 ms (4 ms)
~>"fita"demorou 122 ms (???)
~>"uvu"levou 72 ms (1,3 ms)