A escrita de testes unitários é, indiscutivelmente, um dos pilares da qualidade de software moderno. No entanto, no ecossistema Delphi, muitos desenvolvedores ainda enxergam a criação de suítes de teste (seja em DUnit ou DUnitX) como uma tarefa árdua, verbosa e que “rouba tempo” da implementação de features.

A virada de chave para a produtividade não é parar de testar, mas sim mudar como escrevemos esses testes. Com o uso de Grandes Modelos de Linguagem (LLMs), podemos transformar a criação de cenários de teste, mocks e validações de “edge cases” em um processo quase instantâneo.

Neste artigo, vou explorar uma estratégia prática para injetar classes de negócio em uma IA e obter uma cobertura de testes robusta e pronta para compilar.

O Cenário: A Classe de Negócio

Para demonstrar a técnica, imagine uma classe de serviço comum em sistemas ERP, responsável por calcular o total de um pedido aplicando regras de desconto e impostos.

Essa classe possui dependências (injeção de dependência via interface), o que normalmente complicaria a escrita manual dos testes devido à necessidade de Mocks.

type
  ITaxService = interface
    ['{GUID-DO-INTERFACE}']
    function GetTaxRate(const State: string): Double;
  end;

  TOrderCalculator = class
  private
    FTaxService: ITaxService;
  public
    constructor Create(ATaxService: ITaxService);
    function CalculateTotal(Price: Double; Qty: Integer; const State: string): Double;
  end;

implementation

function TOrderCalculator.CalculateTotal(Price: Double; Qty: Integer; const State: string): Double;
var
  SubTotal, Tax: Double;
begin
  if (Price < 0) or (Qty <= 0) then
    raise Exception.Create('Preço ou quantidade inválidos.');

  SubTotal := Price * Qty;
  
  // Regra de negócio: Desconto de 10% para compras acima de 1000
  if SubTotal > 1000 then
    SubTotal := SubTotal * 0.90;

  Tax := FTaxService.GetTaxRate(State);
  Result := SubTotal * (1 + Tax);
end;

Passo 1: O Prompt de Engenharia (Contexto é Tudo)

O erro mais comum ao usar IA para gerar testes é ser vago. Se você apenas pedir “crie testes para este código”, receberá algo genérico. Para Delphi, precisamos ser específicos sobre o framework (DUnitX é o padrão moderno) e a intenção.

O Prompt Ideal:

“Atue como um Especialista em QA Delphi Sênior. Abaixo está uma classe de negócio (TOrderCalculator) e sua dependência (ITaxService).

Por favor, escreva uma unidade de teste completa utilizando o framework DUnitX.

1. Crie testes para o ‘Caminho Feliz’ (Happy Path).
2. Identifique e cubra Edge Cases (casos de borda) e exceções.
3. Crie Mocks/Stubs manuais ou use um framework de isolamento para a interface ITaxService, garantindo que o teste não dependa de dados externos.
4. Use Assert com mensagens claras.”

Passo 2: Cobrindo “Edge Cases” (Onde a IA Brilha)

Humanos tendem a testar o caminho feliz (o que acontece quando tudo dá certo). A IA, por ter sido treinada com milhões de linhas de código e cenários de falha, é excelente em prever onde seu código pode quebrar.

Ao processar o código acima, a IA provavelmente irá sugerir cenários que você poderia ter esquecido:

1. Valores Negativos: O que acontece se Price for -10?
2. Quantidade Zero: O cálculo deve rodar se Qty for 0?
3. Limiar do Desconto: O teste exato de 1000.00 (limite do if SubTotal > 1000).
4. Inteiros Grandes: Overflow de valores se a quantidade for muito alta?
5. String Vazia: O que ocorre se State for vazio (dependendo da implementação do Mock)?

Exemplo de saída gerada (Snippet DUnitX):

[Test]
[TestCase('TestInvalidPrice', '-10, 5, SP')]
[TestCase('TestInvalidQuantity', '100, 0, SP')]
procedure TestOrderCalculator.TestValidationErrors(const APrice: Double; const AQty: Integer; const AState: string);
begin
  // A IA entende que deve esperar uma exceção
  Assert.WillRaise(
    procedure
    begin
      FCalculator.CalculateTotal(APrice, AQty, AState);
    end,
    Exception,
    'Deve levantar exceção para entradas inválidas'
  );
end;

[Test]
procedure TestOrderCalculator.TestDiscountThresholdBoundary;
begin
  // Testa exatamente o valor 1000 (sem desconto)
  // Mock configurado para retornar taxa 0 para simplificar o assert
  TMockTaxService(FTaxService).SetRate(0); 
  
  var Total := FCalculator.CalculateTotal(100.00, 10, 'SP');
  Assert.AreEqual(1000.00, Total, 0.001, 'Valor exato de 1000 não deve ter desconto');
end;

Passo 3: Mocks e Stubs Sugeridos

Um dos maiores atritos no TDD é criar as classes “falsas” para simular o banco de dados ou APIs. A IA pode gerar a implementação do Mock instantaneamente.

Para o nosso exemplo, a IA pode sugerir um Stub manual simples, que é frequentemente mais rápido e legível que frameworks complexos de Mocking para testes unitários pequenos.

Sugestão gerada pela IA:

type
  // Stub simples para controlar o retorno da taxa
  TStubTaxService = class(TInterfacedObject, ITaxService)
  private
    FFixedRate: Double;
  public
    constructor Create(Rate: Double);
    function GetTaxRate(const State: string): Double;
  end;

{ TStubTaxService }

constructor TStubTaxService.Create(Rate: Double);
begin
  FFixedRate := Rate;
end;

function TStubTaxService.GetTaxRate(const State: string): Double;
begin
  // Retorna valor previsível para o teste
  Result := FFixedRate; 
end;

Com isso, no Setup do seu teste, a injeção fica trivial:

procedure TestOrderCalculator.Setup;
begin
  // Injeta uma taxa de 10% (0.10) para todos os testes por padrão
  FTaxService := TStubTaxService.Create(0.10);
  FCalculator := TOrderCalculator.Create(FTaxService);
end;

Benefícios e Cuidados

A utilização de IA para gerar testes DUnitX traz benefícios imediatos:

• Redução da Carga Cognitiva: Você foca na regra de negócio, a IA foca na “carpintaria” do teste.
• Cobertura Imediata: É fácil passar de 0% para 80% de cobertura de código em minutos.
• Documentação Viva: Os testes gerados servem como documentação de como a classe deve se comportar em situações extremas.

O “Catch” (Atenção): A IA não compila o código. Às vezes, ela pode alucinar métodos que não existem no DUnitX (confundindo com NUnit do C#, por exemplo) ou esquecer de adicionar uma unit no uses. A revisão técnica continua sendo indispensável.

Conclusão

Automatizar a escrita de testes unitários no Delphi não é “trapaça”, é inteligência operacional. Ao delegar a criação de cenários repetitivos, mocks e validações de borda para a IA, o desenvolvedor Delphi ganha tempo para resolver problemas complexos de arquitetura, mantendo a base de código segura e testável.

Experimente pegar aquela classe “legada” que todos têm medo de mexer, peça para a IA gerar os testes, e veja a mágica da refatoração segura acontecer.

Dica Rápida

Você pode usar o GitHub Copilot, ChatGPT ou Claude para isso. Se estiver usando Delphi antigo (DUnit padrão), lembre-se de especificar explicitamente no prompt para evitar a sintaxe baseada em atributos do DUnitX.