Acelerando a geração de testes unitários e melhorando a qualidade do código

Recentemente, tive a oportunidade de me aprofundar no Early, um agente de IA projetado para geração automática de testes unitários. Como alguém que trabalha regularmente com TypeScript e ExpressoTS Framework, estava ansioso para ver como Early poderia agilizar meu fluxo de trabalho. Decidi testar a extensão vscode que eles construíram em minha nova biblioteca NPM que estava desenvolvendo, chamada @expressots/share.

Impressões iniciais

A primeira coisa que me impressionou no Early foi sua capacidade de gerar automaticamente testes de unidade para minha base de código existente. Em vez de criar testes do zero, eu poderia me concentrar em refinar os testes gerados e melhorar a robustez e a testabilidade do meu código. Essa mudança acelerou significativamente meu processo de desenvolvimento. O outro aspecto interessante que notei é que 83% do código gerado não fiz nenhum ajuste, funcionou imediatamente e aumentou minha cobertura de código. Economize muito tempo.

Economia de tempo e maior cobertura

Em apenas 8,5 horas, consegui:

• Gere testes de unidade para aproximadamente 3.000 linhas de código.
• Corrija problemas e melhore a testabilidade do código.
• Alcance uma cobertura total de código de 88% com 96 testes.

O fato de poder realizar tudo isso em um único dia foi notável. O cenário ideal em testes unitários é fazê-lo enquanto você está realmente desenvolvendo suas funções. Fiz isso depois de já ter uma biblioteca instalada, então alguns ajustes foram necessários para tornar o código testável.

Resultados Positivos

Geração automática de testes de casos extremos. Por exemplo, gerou testes unitários para cenários envolvendo strings vazias, mesmo quando parâmetros eram necessários:

export function printSuccess(message: string, component: string): void {
  stdout.write(chalk.green(`${message}:`, chalk.bold(chalk.white(`[${component}] ✔️\n`))));
}

Inicialmente, eu não teria criado testes para strings vazias em uma função tão simples. No entanto, a abordagem de Early promoveu práticas de programação defensivas, forçando-me a lidar com casos extremos que eu poderia ter esquecido.

Detecção de possíveis problemas

Ao refinar os testes gerados, encontrei um problema de incompatibilidade de tipo:

Problema: jest.fn() retorna qualquer, mas process.exit retorna nunca, levando a uma incompatibilidade de tipo no TypeScript.
Solução: Modifique o mock para corresponder à assinatura process.exit, garantindo a correção do tipo.
Essa descoberta me levou a ajustar meu código para melhor segurança de digitação, destacando como o Early pode ajudar a identificar problemas sutis que, de outra forma, poderiam passar despercebidos.

Áreas para Melhoria

Apesar da experiência geral positiva, encontrei alguns desafios que, se abordados, poderiam melhorar a usabilidade do Early:

• Compatibilidade com versões da biblioteca. Testes gerados antecipadamente usando métodos Jest obsoletos em alguns casos, por exemplo:

Usando Jest 29.7

expect(Compiler.loadConfig()).rejects.toThrowError("process.exit() was called with code 1");

// Versão corrigida

expect(Compiler.loadConfig()).rejects.toThrow("process.exit() was called with code 1");

• Opções de personalização para geração de testes Embora a geração de testes para casos extremos tenha sido benéfica, em alguns cenários, pode não ser necessário:

Observação: gerar testes para todas as entradas possíveis, incluindo strings vazias, às vezes pode ser um exagero.

Sugestão: introduza opções para personalizar o nível de geração de testes, permitindo que os desenvolvedores optem por testes de programação defensivos conforme necessário.

• Melhorias na interface do usuário na extensão VSCODE A navegação entre o Early e outras ferramentas destacou algumas limitações da interface do usuário:

Visibilidade dos resultados do teste: tive que alternar entre Early e Jest para ver quais testes foram aprovados ou reprovados.

Estado da árvore de arquivos: a hierarquia do projeto no Early entra em colapso ao voltar de outros aplicativos, exigindo que eu reabra as pastas repetidamente.
Sugestão: Melhore a UI para exibir os resultados dos testes no Early, espelhando a estrutura do Jest. Manter o estado da árvore de arquivos também melhoraria a experiência do usuário.

• Zombaria e segurança de tipo O problema com jest.fn() retornando any sugere a necessidade de uma simulação mais precisa:

Observação: usar qualquer tipo em simulações pode levar a incompatibilidades de tipo e potencialmente mascarar bugs.
Sugestão: Refine a geração de simulação para usar assinaturas precisas, promovendo melhor segurança de digitação e reduzindo a necessidade de correções manuais.

Conclusão

No geral, minha experiência com Early foi altamente positiva. A ferramenta acelerou significativamente meu processo de teste de unidade, permitindo que eu me concentrasse no refinamento dos testes, em vez de escrevê-los do zero. Também me encorajou a considerar casos extremos e melhorar a robustez do meu código.

As áreas de melhoria são relativamente pequenas e giram em torno do aprimoramento da usabilidade e da personalização. Abordar isso tornaria a ferramenta uma aliada ainda mais poderosa no desenvolvimento de software.

Parabéns à equipe Early pelo excelente trabalho! Estou animado para ver como a ferramenta evolui e ficaria feliz em continuar fornecendo feedback para ajudar a refiná-la ainda mais.