Como iniciar um conjunto de testes automatizados quando há 0 testes escritos

Você sabe, há uma certa ansiedade que se insinua quando você dá uma olhada em uma base de código na qual está começando a trabalhar, apenas para perceber que é um vasto deserto desconhecido. Nem um único teste foi escrito para se proteger contra o inesperado.

É como andar na corda bamba sobre um abismo, sabendo que um único passo em falso pode levar todo o seu projeto ao caos.

Se você trabalhou em uma base de código com 0 testes, sabe que pode ser uma tarefa assustadora pensar em cobrir toda a base de código com testes do zero, onde não existem atualmente.

O processo exige um esforço quase hercúleo: você teria que examinar todas as funções, métodos e componentes, fazer um brainstorming de todos os possíveis casos extremos, estruturar o código do conjunto de testes e fazer tudo funcionar sem problemas.

E isso sem falar no tempo que leva para alcançar uma cobertura significativa. Estamos falando de semanas, talvez meses, antes que você possa sentar e dizer: “Sim, atingimos 80% ou 90% de cobertura”.

É por isso que estou animado para compartilhar o que tenho trabalhado nos últimos meses. Esta jornada nos leva a um lugar onde o reino dos testes automatizados encontra o mundo mágico da IA. Conheça o Pythagora, uma ferramenta de desenvolvimento de código aberto que está prestes a se tornar seu novo melhor amigo.

Ao longo desta postagem do blog, mostrarei como iniciar os testes automatizados com o Pythagora , que aproveita o poder da IA para gerar testes para toda a sua base de código, tudo com um único comando CLI e, com sorte, obter sua base de código de 80% a 90 % de cobertura de código em um único dia .

Criando um conjunto de testes do zero

Todos nós conhecemos o ditado: “Roma não foi construída em um dia”. O mesmo pode ser dito de um conjunto de testes abrangente e eficaz. É um processo meticuloso e exigente, mas depois de atravessar esta estrada pedregosa, a sensação de realização é profunda.

Vamos viajar juntos pelas etapas necessárias envolvidas na criação de um conjunto de testes a partir do zero e alcançar a cobiçada cobertura de código de 80% a 90%.

Lançando as bases

No primeiro estágio, você é como um pintor diante de uma tela em branco. O mundo está cheio de possibilidades e você é livre para criar uma obra-prima.

Sua obra-prima, neste caso, envolve escolher os tipos de testes que deseja escrever, encontrar a estrutura de teste certa para usar e adotar as melhores práticas adequadas para seu ambiente específico.

Você está considerando testes de unidade, testes de integração, testes E2E ou uma mistura dos três?

Embora essa configuração inicial seja frequentemente vista como a parte “fácil”, não é de forma alguma um passeio no parque. Tempo, pesquisa e talvez algumas xícaras de café são necessários para tomar decisões informadas.

Mergulhando nos detalhes

Depois de definir sua estrutura básica, é hora de arregaçar as mangas e mergulhar fundo no âmago da questão. Agora, você precisará passar por toda a sua base de código, uma função por vez, e escrever testes para cada uma. Sua tarefa aqui é garantir que seus testes toquem todas as linhas de código dentro de cada função, método ou componente.

Esta tarefa é semelhante a explorar um intrincado labirinto. Você precisa percorrer todos os caminhos, virar todas as esquinas e garantir que nenhuma pedra seja deixada sobre pedra.

Escrever esses testes é uma etapa detalhada e demorada. Não se trata apenas de escrever algumas linhas de código; trata-se de entender o propósito da função, sua saída esperada e como ela interage em seu aplicativo.

Explorando os casos extremos

Após a rodada inicial de testes, você pode respirar aliviado. Espere, porém; ainda resta uma peça importante do quebra-cabeça. É hora de mergulhar no mundo selvagem e imprevisível dos casos extremos .

Esta parte pode não aumentar a porcentagem de cobertura do código, mas é crucial para testar a robustez e resiliência do seu código.

Esses chamados testes negativos ajudam a avaliar como seu código reage a várias entradas, particularmente aquelas que estão à margem do comportamento esperado. De entradas vazias a valores que ultrapassam os limites de seus tipos de dados, esses testes são projetados para imitar o comportamento do usuário no mundo real, onde os usuários geralmente têm o dom de empurrar seu código em direções que você nunca imaginou serem possíveis.

Criar um conjunto de testes do zero é uma tarefa hercúlea. Mas fique tranquilo, cada esforço que você faz é um passo para criar um aplicativo mais robusto, confiável e resiliente.

E lembre-se, você não está sozinho. Todos nós já passamos por isso e, com uma ferramenta como o Pythagora, a jornada não é tão assustadora quanto parece.

Gerando testes com um comando CLI

Por outro lado, com o Pythagora, o que você pode fazer é inserir:

 npx pythagora --unit-tests --path ./path/to/repo

O Pythagora navegará por todos os arquivos em todas as pastas, criando testes de unidade para cada função que encontrar. Agora, você pode sentar e relaxar ou ir almoçar e deixá-lo funcionar por um tempo até terminar de escrever os testes.

Ok, mas espere, o que diabos é Pitágoras??

O que é Pitágoras?

Sempre sonhei com um mundo onde testes automatizados pudessem ser criados para mim. Mas a realidade não é tão simples. Ninguém conhece seu código como você, tornando difícil para outro elaborar testes automatizados eficazes para ele. Os resultados muitas vezes ficam aquém do que você mesmo alcançaria.

No entanto, tudo mudou quando o ChatGPT entrou em cena. Enquanto mexia com essa tecnologia, me perguntei: “Podemos aproveitar o poder do ChatGPT para escrever testes automatizados?”

Curiosidade despertada, mergulhei mais fundo, experimentando suas capacidades, e o que descobri me surpreendeu.

O ChatGPT demonstrou uma capacidade incrível de compreender o código, oferecendo um vislumbre de um novo caminho promissor em testes automatizados.

E assim nasceu uma ideia para Pitágoras.

Pythagora é uma ferramenta de desenvolvimento de código aberto, criada com uma missão em mente: tornar os testes automatizados autônomos . Eu imagino um mundo onde os desenvolvedores, como você e eu, podem se concentrar na criação de recursos sem se atolar na lama de criação de testes e manutenção.

Para alcançar esta visão, está usando GPT-4.

Atualmente, Pythagora tem a proeza de escrever testes de unidade e integração. No entanto, para os propósitos desta postagem no blog, vamos nos concentrar em sua capacidade de gerar testes de unidade.

Instalação

Para instalar o Pythagora, você só precisa fazer npm i pythagora . É isso! Pythagora está agora ao seu serviço.

Configuração

Depois que o Pythagora estiver instalado, você precisará configurá-lo com uma chave de API. Isso pode ser uma chave de API OpenAI ou uma chave de API Pythagora.

Para usar uma chave de API OpenAI, você deve executar o seguinte comando:

 npx pythagora --config --openai-api-key <OPENAI_API_KEY>

É importante observar que, se você optar por usar sua própria chave de API OpenAI, deverá ter acesso ao GPT-4.

Como alternativa, você pode obter uma chave de API do Pythagora neste link . Depois de tê-lo, configure-o com o seguinte comando:

 npx pythagora --config --pythagora-api-key <PYTHAGORA_API_KEY>

Comandos

Caso prefira gerar testes para um arquivo específico, utilize:

 npx pythagora --unit-tests --path ./path/to/file.js

E se você tiver uma função específica em mente, use:

 npx pythagora --unit-tests --func <FUNCTION_NAME> 

Como Pitágoras Funciona?

Vamos abrir a cortina e dar uma espiada na casa das máquinas. O que move Pitágoras?

Em sua essência, o Pythagora funciona como um explorador intrépido, mergulhando no intrincado labirinto de sua base de código. Primeiro, ele mapeia todas as funções que são exportadas de seus arquivos para que possa chamá-las de dentro dos testes.

Obviamente, se uma função não for exportada, ela não poderá ser chamada de fora de seu arquivo. Aliás, depois de gerar testes algumas vezes, isso fará você pensar sobre sua base de código e como você pode estruturá-la melhor para que mais testes possam ser gerados.

Depois de identificar as funções exportadas, o Pythagora dá mais um passo na toca do coelho: ele investiga cada função por vez, caçando quaisquer funções adicionais chamadas dentro.

Imagine-o como o arqueólogo de sua base de código, removendo suavemente as camadas de poeira para expor as conexões e dependências ocultas.

Em outras palavras, ele procura todas as funções chamadas de dentro da função que está sendo testada para que o GPT possa entender melhor o que faz uma função para a qual os testes estão sendo escritos.

Armado com esta informação, Pythagora se prepara para utilizar o poder da IA. Ele empacota o código coletado e o despacha para a API do Pythagora. Aqui, a verdadeira mágica acontece: um prompt é meticulosamente elaborado e entregue ao modelo GPT.

Essa interação entre o código, a API e o modelo de IA resulta na geração de um conjunto abrangente de testes de unidade, prontos para serem implantados e colocados em funcionamento.

Tanto o servidor de API quanto os prompts usados são de código aberto. Eles estão disponíveis para você se aprofundar, examinar e até mesmo contribuir, se assim o desejar. Você pode encontrar o servidor da API Pythagora aqui , enquanto os prompts e os principais ingredientes na criação de testes de unidade estão alojados nesta pasta .

Testes de revisão

Depois que o Pythagora escreve todos os testes solicitados, é hora de você começar a revisá-los. Esta é uma etapa vital no processo; é importante saber o que foi criado e garantir que tudo esteja de acordo com suas expectativas.

Lembre-se, Pythagora cria testes baseados em Jest. Então, para rodar todos os testes gerados, basta rodar:

 npx jest ./pythagora_tests/

Agora, uma palavra de cautela: Pitágoras ainda está em seus estágios iniciais. Como acontece com todos os projetos jovens, é provável que haja alguns percalços ao longo do caminho. Portanto, você pode encontrar testes com falha em suas execuções iniciais.

Não desanime; considere isso uma parte da jornada. Com sua revisão e as melhorias contínuas do Pythagora, esses testes com falha logo serão coisa do passado.

E não vamos esquecer o lado bom. Mesmo com esses problemas iniciais, o Pythagora pode levá-lo a um ponto em que sua base de código tenha uma cobertura de teste substancial, potencialmente de até 90% .

Testes de confirmação

O processo de revisão, especialmente para bases de código maiores, pode levar algumas horas. Lembre-se, você não está olhando apenas para os testes que passaram, mas também para aqueles que falharam. É crucial entender todos os testes que você está enviando para o seu repositório. Conhecimento é poder, afinal.

Após uma revisão completa e possíveis ajustes, você está pronto para fazer sua jogada final: confirmar os testes gerados em seu repositório. Com esta última etapa, você teria integrado com sucesso um conjunto robusto de testes de unidade em seu projeto.

E tudo isso com o poder do Pythagora e algumas linhas de comando no seu terminal.

Testes de exemplo no Lodash Repo

Tudo bem, agora que despertei seu interesse, vamos nos aprofundar nas coisas reais – exemplos tangíveis de Pitágoras em ação. Para fins de nossa demonstração, selecionamos um conhecido projeto de código aberto, o Lodash .

A execução de apenas um comando do Pythagora foi suficiente para gerar 1.604 testes, alcançando uma impressionante cobertura de código de 91% de todo o repositório Lodash. Mas não é só a quantidade de testes que impressiona.

Destes, 13 testes desenterraram bugs reais dentro do ramo mestre Lodash.

Se você estiver curioso para conferir por conta própria, bifurcamos o repositório Lodash e adicionamos os testes gerados pelo Pythagora. Sinta-se à vontade para explorá-los aqui .

Agora, vamos dar uma olhada em um dos testes que detectou um bug sorrateiro:

 test(`size({ 'a': 1, 'b': 2, 'length': 9 })`, () => { expect(size({ 'a': 1, 'b': 2, 'length': 9 })).toBe(3); // test returns 9 });

Neste teste, a função size de Lodash deve retornar o tamanho de um objeto JSON. Porém, o GPT adicionou uma chave chamada length , um pequeno truque para ver se Lodash pode retornar o valor dessa chave em vez do tamanho real do objeto.

Parece que Lodash caiu nesse ardil, pois o teste falhou ao retornar '9' em vez do esperado '3'.

Este é um exemplo fantástico de como o Pythagora, alimentado por GPT, se destaca em descobrir casos complicados que poderiam facilmente passar despercebidos.

Ao gerar automaticamente um grande número desses casos de teste intrincados, o Pythagora pode ser seu parceiro de confiança, ajudando você a descobrir e corrigir bugs que você nunca imaginou.

Conclusão

Bem, aí está, colegas desenvolvedores. Embarcamos em uma jornada e tanto hoje, atravessando os territórios desconhecidos de uma base de código substancial desprovida de testes e retornando com um conjunto automatizado de testes criados por nossa confiável ferramenta com tecnologia de IA, Pythagora.

Você aprendeu que, mesmo diante de uma base de código assustadora e sem testes, não há necessidade de desespero. A tarefa de criar um conjunto substancial de testes não precisa mais ser uma tarefa árdua.

Testemunhamos a magia de Pythagora ao examinar uma conhecida biblioteca de código aberto, Lodash, e gerar 1.604 testes que cobriam impressionantes 91% da base de código .

Vimos como Pitágoras não se trata apenas de quantidade, mas também da qualidade dos testes. Não é apenas criar testes por fazer, mas encontrar de forma inteligente casos extremos e bugs que, de outra forma, poderiam ter passado despercebidos.

Pythagora desmascarou 13 bugs reais no ramo mestre Lodash – uma prova do poder da IA no teste de software.

Agora, você deve ter uma compreensão mais clara de por que as ferramentas de teste com tecnologia de IA, como o Pythagora, não são apenas um luxo, mas uma necessidade no atual cenário de desenvolvimento acelerado.

Então, se você está lidando com um projeto existente com zero testes ou iniciando um novo e procurando estabelecer uma estrutura de teste sólida desde o início, lembre-se de que você não está sozinho.

Pythagora está aqui para tomar as rédeas, ajudando você a gerar testes significativos com facilidade e economizando um tempo valioso que pode ser melhor gasto no desenvolvimento de ótimos recursos.

Obrigado por se juntar a mim nesta jornada e mal posso esperar para ver como você utilizará o Pythagora em seus projetos. Codificação feliz!

PS Se você achou esta postagem útil, significaria muito para mim se você estrelasse o repositório Github do Pythagora , e se você experimentar o Pythagora, informe-nos como foi [email protected]