Escreva testes de unidade para seu código Python com o ChatGPT – Real Python

Escrevendo casos de teste

O unittest fornece o módulo TestCase base classeque o senhor pode usar para escrever casos de teste por meio de subclasses. Diferente de doctest, unittest é uma ferramenta para criar casos de teste elaborados em módulos independentes que o senhor pode agrupar em um tests/ no diretório raiz do seu projeto ou em qualquer outro local.

Novamente, o senhor pode pedir ao ChatGPT para escrever unittest para o senhor. Aqui está um prompt rápido para fazer isso. Lembre-se de iniciar um novo tópico de bate-papo antes de executar o prompt:

O senhor: Escreva unittest casos de teste para a seguinte função:

ChatGPT:

Para escrever unittest casos de teste para o fizzbuzz() o senhor precisa seguir estas etapas:

1. Importar o arquivo unittest módulo.
2. Defina uma classe de teste que herda do unittest.TestCase.
3. Escreva métodos de teste dentro dessa classe para testar diferentes aspectos do fizzbuzz() função.
   • Cada método de teste deve começar com a palavra test.
   • Use asserções como self.assertEqual() para verificar a saída da função em relação aos resultados esperados.
4. Por fim, chame o unittest.main() para executar os testes quando o script for executado.

Veja como o senhor pode estruturar seus casos de teste para o fizzbuzz() :

Para executar esses testes, salve o código em um arquivo .py e execute-o com o Python. O unittest descobrirá automaticamente os métodos de teste em TestFizzBuzz e os executará, relatando os resultados.

Essa resposta também é excelente! O bate-papo oferece uma ótima explicação de como organizar seus casos de teste quando você estiver usando unittest. Em seguida, ele gera o código para os testes.

Observe que cada teste inclui várias asserções com diferentes argumentos e resultados. Essa abordagem pode ser adequada quando o senhor precisa testar várias propriedades relacionadas em um objeto. No seu exemplo, essa abordagem funciona bem porque as asserções combinadas testam um único valor de retorno.

O uso de várias asserções ajuda a reduzir o código boilerplate. Em geral, essa abordagem tem os seguintes prós:

• Eficiência: Várias asserções em um único teste podem reduzir o código repetitivo. Isso também pode fazer com que os testes sejam executados mais rapidamente nos cenários em que o senhor tem requisitos de configuração e desmontagem para cada teste.
• Testes contextuais: Talvez sejam necessárias várias asserções para verificar se uma função se comporta corretamente em um contexto específico.
• Conveniência: Várias asserções em um teste podem ser mais simples e menos tediosas de escrever em comparação com a escrita de vários testes de asserção única.

Essa abordagem também tem seus contras:

• Clareza e isolamento: Quando um teste com várias asserções falha, pode ser mais difícil identificar imediatamente qual asserção causou a falha. Isso pode ir contra seu processo de depuração.
• Risco de quebra: Quando uma afirmação inicial em um teste falha, as afirmações subsequentes não são executadas. Isso pode ocultar outros problemas.
• Desfoque da finalidade do teste: Quando um teste tem várias afirmações, ele pode se tornar menos focado. Isso pode tornar o teste mais difícil de entender.

Por fim, o ChatGPT fornece ao senhor instruções rápidas sobre como executar os testes. O senhor já tem um fizzbuzz.py contendo o arquivo fizzbuzz() . Portanto, vá em frente e crie o arquivo chamado test_fizzbuzz_unittest.py e cole somente o código relacionado ao teste:

Nesse arquivo, o senhor copiou o código relacionado ao teste como o chat o gerou. Observe que o senhor importou o código fizzbuzz() da sua função fizzbuzz.py para que os testes sejam executados. Agora, vá em frente e execute o seguinte comando para executar os testes:

Esse comando executa o teste a partir do arquivo test_fizzbuzz_unittest.py usando a interface de linha de comando do unittest. O -v gera uma saída detalhada que aproveita as documentações dos testes para fornecer contexto sobre o que é cada teste.

Como o código na resposta do chat inclui o idioma name-main envolvendo o unittest.main() o senhor também pode executar os testes com executando o test_fizzbuzz_unittest.py como um script Python comum.

Criação de dispositivos

Um dispositivo de teste é uma preparação que o senhor precisa realizar para um ou mais testes e quaisquer ações de limpeza associadas. O código de configuração pode envolver a criação de arquivos temporários, objetos, bancos de dados, conjuntos de dados, conexões e assim por diante.

Para ilustrar como os dispositivos funcionam no unittest, digamos que o senhor tenha criado um readers.py que implementa um arquivo JSONReader que se parece com o seguinte:

O senhor precisa escrever unittest para sua classe. Esses testes precisarão de preparação. Por exemplo, o senhor pode escrever um fixture de configuração para criar um arquivo temporário com algum conteúdo de amostra. Em seguida, o senhor pode remover o arquivo após a execução dos testes no estágio de desmontagem.

Aqui está um prompt rápido que o senhor pode usar com o ChatGPT para escrever os dispositivos e os testes apropriados:

O senhor: Escreva unittest casos de teste com acessórios para a classe a seguir:

ChatGPT:

Para escrever unittest casos de teste com acessórios para o JSONReader o senhor precisará seguir estas etapas:

1. Use os métodos de configuração e desmontagem para preparar e limpar os dispositivos de teste. Esses métodos podem ser .setUp() (executado antes de cada método de teste) e .tearDown() (é executado após cada método de teste) para o gerenciamento de recursos.
2. No método de configuração, crie um arquivo JSON temporário que o JSONReader lerá.
3. Escreva métodos de teste para verificar se o JSONReader lê corretamente o conteúdo JSON de um arquivo.
4. Use o método teardown para limpar todos os recursos, como excluir o arquivo temporário criado para teste.

Veja como o senhor pode implementar essas etapas em um unittest caso de teste:

Este exemplo demonstra como:

• Usar .setUp() para preparar um arquivo JSON temporário que o JSONReader usará para leitura.
• Escreva um teste básico (.test_read_json()) para verificar se o JSONReader pode ler corretamente os dados JSON de um arquivo.
• Escreva um teste (.test_file_not_found()) para verificar como o JSONReader se comporta quando o arquivo não existe, esperando um FileNotFoundError.
• Utilização .tearDown() para fazer a limpeza, excluindo o arquivo temporário após cada teste.

Para executar esses testes, salve o código em um arquivo .py e execute-o com o Python. O unittest descobrirá e executará automaticamente os testes, informando os resultados.

Em sua resposta, o chat primeiro lista as etapas necessárias para escrever casos de teste e dispositivos para a classe de destino. Em seguida, ele gera o código de teste. O .setUp() cria o arquivo temporário necessário com alguns dados de amostra usando o método tempfile da biblioteca padrão. O método .tearDown() remove o arquivo temporário como uma ação de limpeza. Em geral, o código parece bom e bem organizado.

Observe que o senhor encontrará alguns problemas de estilo de codificação no código gerado. Por exemplo, em vez de formalizar o docstrings, as funções de teste começam com um comentário. Além disso, alguns atributos podem não ter nomes descritivos e, em alguns casos, o senhor encontrará construções desnecessárias, como o uso de um variável descartável no último teste. O senhor pode corrigir manualmente esses problemas para atender aos seus requisitos de estilo de codificação.

O senhor já tem um readers.py que contém seu arquivo JSONReader . Vá em frente e crie um arquivo chamado test_readers_unittest.py e copie o código gerado. Lembre-se de remover a classe e importá-la de seu readers.py do arquivo. Em seguida, execute o seguinte comando para executar os testes:

Ótimo! Os testes foram aprovados e o código gerado funciona corretamente.

Criando suítes de teste

Usando unittest, o senhor pode criar conjuntos de testes para agrupar testes. Dessa forma, é possível executar seletivamente um conjunto de testes em seu código, o que pode ser conveniente nas situações em que os testes levam muito tempo para serem executados. Nesse caso, talvez seja necessário um atalho que permita executar apenas o teste relacionado ao código em que está trabalhando.

Para ilustrar como criar testes e agrupá-los com conjuntos de testes usando o ChatGPT, digamos que o senhor tenha um módulo chamado calculations.py que define operações aritméticas e estatísticas básicas:

O senhor precisa gerar unittest para todas as funções deste módulo. Aqui está um prompt rápido que o senhor pode usar para concluir essa tarefa:

O senhor: Escreva unittest casos de teste para o módulo a seguir:

ChatGPT:

Para testar o módulo que o senhor forneceu, que contém funções para operações aritméticas básicas e cálculos estatísticos, é possível seguir a estrutura descrita abaixo. Essa estrutura inclui testes para cada função, garantindo que elas lidem com casos típicos e casos extremos, como a divisão por zero ou o cálculo do modo de um conjunto de dados com vários modos:

Esse conjunto de testes abrange cada função do módulo fornecido. As operações aritméticas são testadas com valores positivos, negativos e zero. As operações estatísticas são testadas com listas de vários comprimentos e composições, incluindo casos extremos:

• Para divide(), ele testa a divisão por zero, esperando um ValueError.
• Para mean()ele testa com listas de tamanhos pares e ímpares.
• Para median()ele testa tanto o número par quanto o ímpar de elementos na lista, incluindo um teste em que os dados não são inicialmente classificados.
• Para mode()ele testa tanto quando há um único modo quanto quando há vários modos na lista.

Para executar esses testes, certifique-se de que as funções do módulo estejam definidas no mesmo arquivo ou importadas corretamente para o arquivo de teste e, em seguida, execute o arquivo de teste com o Python. O unittest descobrirá e executará automaticamente os testes, informando os resultados.

Ótimo! O senhor tem casos de teste para todas as funções do seu calculations.py do módulo. Os diferentes testes estão agrupados em dois TestCase subclasses. A primeira agrupa as funções aritméticas básicas e a segunda agrupa as funções estatísticas. Essa é uma ótima maneira de estruturar seus testes.

Há um pequeno detalhe que o senhor deve observar nesse código gerado. O chat está importando o Counter da classe collections . Essa importação não é necessária porque o código de teste não usa a classe. Portanto, o senhor pode remover essa importação com segurança.

Antes de tentar executar os testes, vá em frente e importe todas as funções do seu calculations.py do módulo. Em seguida, execute o seguinte comando, que executa todos os testes do módulo test_calculations.py :

Todos os testes foram aprovados! Nesse caso, o senhor não usou o -v da linha de comando para que o senhor não obtenha a saída detalhada.

Agora, digamos que o senhor queira executar o teste de forma independente. Por exemplo, o senhor pode querer executar os testes das funções aritméticas separadamente dos testes das funções estatísticas. O senhor pode usar unittest para esse fim.

Aqui está um prompt para pedir ajuda ao bate-papo. Lembre-se de permanecer no mesmo tópico de bate-papo:

O senhor: Escreva unittest conjuntos de testes para agrupar as funções aritméticas e as funções estatísticas.

ChatGPT:

Para agrupar os testes de funções aritméticas e estatísticas em conjuntos de testes separados usando o unittest do Python, o senhor pode usar o comando TestSuite class:

Esse script define duas classes de teste, TestArithmeticOperations e TestStatisticalOperationscada um contendo testes relevantes para sua categoria. O load_tests() é usada para criar um conjunto de testes que combina testes de ambas as classes, gerenciando um total de 10 testes. Essa função é um gancho fornecido pelo unittest para personalizar o carregamento de testes e a criação de suítes. Ela é chamada automaticamente quando se usa o unittest.main().

Para executar os testes, certifique-se de que as funções do seu módulo estejam definidas no mesmo arquivo ou importadas corretamente para o arquivo de teste e, em seguida, execute o arquivo de teste com o Python. O unittest descobrirá a estrutura do load_tests() usará a função para construir o conjunto de testes e executará os testes, relatando os resultados.

Na resposta acima, o chat gerou dois TestCase que são semelhantes às criadas anteriormente. Em seguida, ele gera o load_tests() função. Neste exemplo, a função define um conjunto de testes, incluindo os dois casos de teste.

Se o senhor executar o código como está, estará executando todos os testes. No entanto, se o senhor comentar uma das chamadas para .addTests() em load_tests() o senhor estará executando testes específicos. Para experimentar esses testes atualizados, vá em frente e substitua o conteúdo de sua função test_calculations.py pelo código acima. Lembre-se de importar as funções de calculations.py.

Em seguida, comente a linha que adiciona o TestArithmeticOperations e execute o seguinte comando:

Quando o senhor comenta a linha que adiciona os testes aritméticos, seu código executa apenas os testes estatísticos.

O uso de suítes de teste tem vários benefícios. Alguns dos mais relevantes são os seguintes:

• Organizar seus testes: O senhor pode usar suítes de teste para agrupar os testes de forma lógica, de modo que eles sejam mais fáceis de manter e de entender.
• Execute seu teste seletivamente: Nas fases de desenvolvimento ou depuração, talvez o senhor queira executar apenas um subconjunto de testes que sejam relevantes para a parte do código em que está trabalhando. O senhor pode fazer isso com conjuntos de testes.
• Melhorar o desempenho ao executar o teste: O senhor pode ter conjuntos de testes para diferentes conjuntos de recursos em seu aplicativo, de modo a evitar a execução de todos os testes sempre que atualizar o código.

As suítes de teste são um recurso poderoso do unittest que aprimoram a organização, a execução e a manutenção dos testes, tornando-os particularmente úteis em cenários de testes complexos.

Escrevendo testes

Em pytest, o senhor pode escrever testes como funções normais. O senhor não precisa fazer uma subclasse de uma classe base ou usar métodos específicos da API de uma estrutura. Portanto, escrever testes com pytest é rápido e flexível.

Para escrever alguns pytest com o ChatGPT, inicie um novo tópico de bate-papo. Em seguida, emita o seguinte prompt:

O senhor: Escreva pytest casos de teste para a seguinte função:

ChatGPT:

Com certeza! Para escrever pytest casos de teste para o fizzbuzz() o senhor precisa primeiro se certificar de que tem a função pytest instalado. Se não estiver instalado, o senhor pode instalá-lo usando pip install pytest.

Aqui estão alguns exemplos de casos de teste que abrangem todas as ramificações do fizzbuzz() da função:

Para executar esses testes, o senhor os salvará em um arquivo (digamos test_fizzbuzz.py) e, em seguida, executar pytest no terminal, no diretório em que seu arquivo de teste está localizado. O Pytest descobrirá automaticamente os testes que são prefixados com test_ e os executará.

Nessa resposta, o senhor tem cinco funções de teste separadas. Cada função testa um cenário diferente. É importante observar que o senhor não precisa importar pytest no início do módulo para que o código funcione.

Observe que o ChatGPT gerou funções com uma única asserção cada. Essa abordagem é diferente do que foi feito com a função unittest testes. Em geral, o uso de uma única asserção por teste tem as seguintes vantagens:

• Clareza e foco: Os testes com asserções únicas tendem a ser mais focados em um resultado esperado específico.
• Depuração e manutenção: Os testes de asserção única falham e fica imediatamente claro o que deu errado, pois há apenas um motivo para a falha.
• Granularidade nos resultados dos testes: Os testes de asserção única fornecem uma visão granular da funcionalidade que o teste está verificando.

Os testes de asserção única também têm alguns contras:

• Aumento do número de testes: Ter uma asserção por teste pode levar a um grande número de funções de teste, o que pode desordenar o conjunto de testes e dificultar a navegação e a manutenção.
• Sobrecarga de desempenho: A execução de um grande número de testes pode ser mais lenta do que a execução de um número menor. Por exemplo, a repetição do mesmo código de configuração em vários testes pode causar sobrecarga de desempenho.

Como diz ChatGPT, o senhor precisa instalar o pytest para poder executar esses testes. Então, vá em frente e execute o seguinte comando em seu Python ambiente:

Este comando fará o download pytest do site do Índice de pacotes Python (PyPI) e instale-o em seu ambiente Python atual.

Agora, o senhor está pronto para executar os testes gerados. Vá em frente e crie um arquivo chamado test_fizzbuzz_pytest.py e adicione o código acima a ele. Lembre-se de importar seu fizzbuzz() . O senhor também pode remover a função pytest import. Quando o arquivo estiver no lugar, execute o seguinte comando:

Seus testes funcionam como esperado. Eles testam quatro cenários diferentes e seu código é aprovado em todos eles.

Parametrização de testes

Como o senhor já aprendeu, pytest permite que o senhor parametrize as funções de teste. Essa parametrização é muito útil, pois permite que o senhor não precise escrever uma função de teste para cada conjunto de parâmetros. Assim, o senhor pode escrever menos funções de teste e ter mais testes ao mesmo tempo. Isso reduz o código repetitivo e aumenta sua produtividade.

O senhor usará o @pytest.mark.parametrize para definir vários conjuntos de argumentos para uma função ou classe de teste.

Supondo que esteja seguindo o exemplo da seção anterior e que tenha o mesmo thread de chat ativo, é possível usar o seguinte prompt para pedir ao ChatGPT que atualize o teste para você:

O senhor: Atualize os testes anteriores usando a parametrização para evitar repetições.

ChatGPT:

Para atualizar os casos de teste anteriores para o fizzbuzz usando o recurso de parametrização do pytest, podemos consolidá-los em uma única função de teste que usa diferentes valores de entrada e saídas esperadas como parâmetros. Essa abordagem reduz a repetição e torna o conjunto de testes mais conciso e de fácil manutenção. Veja como o senhor pode fazer isso:

Nesta versão atualizada, o @pytest.mark.parametrize é usado para executar o decorador test_fizzbuzz() várias vezes com diferentes conjuntos de argumentos (input e expected). Cada tupla na lista passada para o decorador representa um caso de teste, em que o primeiro elemento é a entrada para o fizzbuzz() e o segundo elemento é o resultado esperado.

Essa abordagem permite que o senhor cubra uma ampla gama de cenários de teste com uma única função de teste, tornando o código de teste mais limpo e reduzindo a redundância. Além disso, adicionar novos casos de teste é tão simples quanto adicionar uma nova tupla à lista de parâmetros, melhorando a capacidade de manutenção do conjunto de testes.

Agora, o senhor tem uma única função de teste chamada test_fizzbuzz(). Entretanto, com a parametrização, essa função funciona como oito testes diferentes – um para cada par de parâmetros.

O uso da parametrização nos testes oferece várias vantagens. Ela reduz a duplicação de código, tornando seu conjunto de testes mais conciso. Também melhora a cobertura do teste e simplifica a manutenção do código. Em resumo, a parametrização é um ótimo recurso do pytest que o senhor acabará adorando.

Atualize seu test_fizzbuzz_pytest.py com o código acima. Em seguida, importe fizzbuzz() e execute o seguinte comando para executar os testes:

$ python -m pytest test_fizzbuzz_pytest.py
======================== test session starts ========================
platform darwin -- ...
rootdir: .../examples
collected 8 items

test_fizzbuzz_pytest.py .............                          [100%]

========================= 8 passed in 0.03s =========================

Na saída, o senhor pode ver que pytest coletou oito testes no total. Isso significa que ele conta cada conjunto de parâmetros como um teste individual.

Criação de dispositivos

O senhor também pode criar dispositivos de código no pytest para lidar com a lógica de configuração e desmontagem. Para fazer isso, o senhor pode usar o @pytest.fixture decorator.

Para continuar com os exemplos de código que o senhor viu até agora, volte ao seu JSONReader. Agora, emita o seguinte prompt em sua janela do ChatGPT. Lembre-se de continuar na janela pytest thread:

O senhor: Escreva pytest casos de teste com acessórios para a classe a seguir:

ChatGPT:

Para escrever pytest casos de teste para o JSONReader incluindo o uso de fixtures para configurar os arquivos de teste necessários, siga as etapas abaixo. Primeiro, certifique-se de que o senhor tenha pytest instalado.

1. Configuração do dispositivo: Crie um dispositivo que configure um arquivo JSON temporário, que será usado pelos testes. Esse acessório criará um arquivo antes da execução de cada teste e o excluirá depois para garantir que os testes não interfiram uns nos outros.
2. Casos de teste: Escreva casos de teste para verificar se o JSONReader pode ler corretamente os arquivos JSON. Isso inclui testar a leitura correta do conteúdo e o tratamento de possíveis exceções (por exemplo, arquivo não encontrado).

Aqui está um exemplo de como o arquivo de teste pode parecer:

Neste exemplo, tmp_path é um recurso interno do pytest que fornece um diretório temporário exclusivo para a função de teste que o solicita. Nós o usamos para criar um arquivo JSON temporário para teste. O setup_json_file cria um arquivo temporário com algum conteúdo JSON e retorna o caminho para esse arquivo, que é então usado pelo test_read_json_correctly função de teste.

O test_file_not_found testa o comportamento da função JSONReader ao tentar ler um arquivo inexistente, esperando um FileNotFoundError seja gerado.

Essa configuração garante que os testes sejam isolados e não dependam ou interfiram em arquivos externos, tornando seus testes mais confiáveis e portáteis.

Nessa resposta, o senhor tem um dispositivo de teste que cria um arquivo temporário para salvar o conteúdo da amostra JSON. Em pytest, o tmp_path oferece uma maneira rápida de criar diretórios temporários. Não é necessário remover explicitamente o diretório temporário, pois o dispositivo cuida dessa tarefa para você.

A resposta não é perfeita. Em vez de docstrings formais, as funções de teste começam com um comentário, mas isso é um problema de estilo de codificação. Outro detalhe que aparece é que a resposta inclui uma importação desnecessária. O dispositivo e os testes não usam o os portanto, o senhor pode remover o módulo importaçãoe seu código de teste estará pronto para ser testado. Nesse caso, import pytest é necessário, pois é usado para definir seu dispositivo.

Veja como executar os testes:

Os testes foram executados com sucesso! Portanto, o dispositivo está funcionando corretamente.

Incluindo somente assinaturas em seus prompts

Para ilustrar como criar prompts que usam a assinatura de suas classes, métodos e funções, considere a assinatura de uma função que verifica se um número está em um determinado intervalo. Lembre-se de iniciar um novo tópico de bate-papo antes de executar o prompt abaixo:

O senhor: Escreva pytest testes para uma função com a seguinte assinatura:

ChatGPT:

Para escrever pytest testes para a função in_interval(number: int, start: int, end: int) -> bool, primeiro precisamos definir a função com base em sua assinatura. Essa função deve retornar True se number estiver entre start e end (inclusive), e False caso contrário. Vamos definir essa função e, em seguida, escrever várias pytest casos de teste para cobrir vários cenários, inclusive casos extremos.

Primeiro, aqui está uma implementação simples do in_interval :

Agora, vamos escrever a função pytest . Crie um novo arquivo Python para seus testes, por exemplo, test_in_interval.pye inclua o seguinte código:

Esse arquivo de teste usa pytest.mark.parametrize para definir vários casos de teste para o in_interval . Cada caso de teste especifica um number, start, end, e o expected resultado. Essa abordagem permite que o senhor teste com eficiência sua função com uma variedade de entradas para garantir que ela se comporte corretamente em diferentes condições.

Neste exemplo, a assinatura da função é o único contexto que o senhor fornece ao ChatGPT. O modelo de linguagem é inteligente o suficiente para examinar o nome e os argumentos da função e gerar uma implementação adequada. Esse pode não ser o caso das funções do mundo real.

Em seguida, o chat gera uma função de teste com oito conjuntos de parâmetros. Cada conjunto de parâmetros testa a função em um cenário específico.

Observe que ter nomes descritivos de funções e argumentos é fundamental nesse tipo de prompt. Adição de dicas de tipo na assinatura da função também melhorará a qualidade da documentação gerada.

Prompts de redação que usam descrições de código

O senhor também pode criar um prompt apenas descrevendo a entrada e a saída do seu código ou fornecendo uma descrição detalhada do que o código faz. Novamente, esses prompts são úteis quando o senhor não tem permissão para carregar o código como parte do prompt.

Para ilustrar, aqui está um prompt que pede ao ChatGPT para escrever testes para uma função que determina se um número inteiro é primo:

O senhor: Escreva pytest testes para uma função que recebe um número inteiro como argumento e determina se ele é um número primo.

ChatGPT:

Para escrever pytest para uma função que determina se um determinado número inteiro é um número primo, primeiro precisamos definir a função. Aqui está uma implementação simples de tal função, que chamaremos de is_prime. Essa função retorna True se o número for primo, e False caso contrário:

Agora, vamos escrever o pytest . Crie um novo arquivo Python para seus testes, por exemplo, test_is_prime.pye inclua o seguinte código:

Esse arquivo de teste usa pytest.mark.parametrize para especificar vários casos de teste para o is_prime função. Cada caso de teste fornece um number para testar e o expected resultado (Verdadeiro ou Falso). Essa configuração permite que o senhor teste de forma abrangente sua função em relação a uma variedade de entradas, incluindo casos extremos, como o menor número primo, números compostos, o número um, zero e números negativos.

Novamente, o chat gerou uma possível implementação para a função. Depois disso, ele gera os testes. O senhor deve fornecer descrições mais detalhadas para funções, classes ou outras partes de código mais complexas para que o ChatGPT possa gerar respostas melhores.

Também é importante observar que esses testes são apenas um ponto de partida. Cabe ao senhor modificá-los e ajustá-los conforme necessário para corresponder ao seu código específico. De qualquer forma, eles podem evitar que o senhor escreva muito código padrão.