Do Acoplamento à Resiliência: A Evolução Arquitetural do Rad IA (v0.0.26 a v0.0.28)

Se você desenvolve em Delphi, sabe que integrar componentes com a IDE através da Open Tools API (OTA) sempre foi um desafio — principalmente quando o assunto é testabilidade. Manter a IDE responsiva enquanto threads em background realizam chamadas de rede assíncronas para APIs de Inteligência Artificial exige uma arquitetura blindada.

Nas últimas semanas, o Rad IA (nosso assistente de IA focado em Delphi) passou por uma transformação profunda. Saímos de um acoplamento direto com a IDE e APIs de rede para um modelo arquitetural moderno, com inversão de controle, isolamento completo em testes unitários offline e testes automatizados de estresse de rede.

Neste artigo, vou guiar você pela jornada técnica das versões v0.0.26, v0.0.27 e a recém-lançada v0.0.28, detalhando os padrões de projeto (Design Patterns) aplicados que você também pode adotar nos seus projetos Delphi.

v0.0.26: Identidade Visual Premium e Inversão de Controle (IoC)

A versão v0.0.26 focou em duas frentes: entregar uma experiência visual mais agradável para o desenvolvedor e reestruturar os alicerces do código.

1. Injeção de Dependências com TRadIAContainer

Até então, várias partes do plugin consumiam classes utilitárias e clientes HTTP de forma direta e acoplada. Para resolver isso, implementamos um container de Inversão de Controle (IoC) thread-safe: a classe TRadIAContainer. A partir dela, desacoplamos serviços essenciais sob interfaces:

• IRadIAHttpClient: Nosso client HTTP centralizado.
• IRadIAErrorDecoder: Decodificador inteligente de payloads de erro das IAs.
• IRadIALocalizer: Dicionário local de mensagens e tradução.

2. O Padrão IRadIAIDEAdapter

Para que pudéssemos rodar testes unitários sem abrir a IDE do Delphi física, criamos a abstração IRadIAIDEAdapter. Nos testes unitários, injetamos um mock da IDE em memória; em produção, a IDE real do Delphi assume o controle. Isso eliminou por completo o risco de testes automatizados corromperem dados de produção locais do desenvolvedor (como arquivos de histórico e chaves de API), pois passamos a injetar diretórios temporários baseados em GUIDs nos testes.

3. Detalhes Visuais

Substituímos o robô genérico do chat por logotipos SVGs oficiais e coloridos de cada provedor (Gemini, OpenAI, Claude, DeepSeek, etc.) e adicionamos um dropdown visual moderno integrado na barra de ferramentas da IDE.

v0.0.27: Saneamento do SonarQube e Testes Síncronos via RTTI

Com as abstrações estruturadas, a versão v0.0.27 focou em elevar a qualidade do código através de análise estática e expansão da cobertura de testes.

1. Qualidade de Código com SonarQube

Submetemos a base de código a um rigoroso escaneamento do SonarQube. Eliminamos 100% dos code smells (pendências técnicas) detectados no barramento de testes:

• Limpeza de imports não utilizados nas cláusulas uses.
• Padronização de nomenclatura Pascal (ex: migração sistemática do método Writeln legado para o moderno WriteLn).

2. Testando Escopo Protegido com RTTI

Um problema comum em testes unitários é a validação de métodos protegidos (protected) ou virtuais de classes base sem expô-los publicamente. Resolvemos isso utilizando a RTTI (Run-Time Type Information) do Delphi. Criamos helpers baseados em RTTI para exercitar métodos como GetBaseUrl e GetModelsDiscoveryUrl de todos os provedores em cenários síncronos e 100% isolados offline.

v0.0.28: Padrão Adapter para a Open Tools API e Resiliência de Rede

A versão v0.0.28 representa a consolidação da testabilidade e da estabilidade no projeto.

1. Desacoplando a ToolsAPI com IRadIAEditorAdapter

A Open Tools API do Delphi é repleta de interfaces globais como IOTAEditor e IOTAEditBuffer. O código que manipula o buffer do editor de texto anteriormente dependia diretamente dessas units. Para desacoplá-lo, introduzimos o padrão Adapter:

• Interface: IRadIAEditorAdapter define ações abstratas como ler texto selecionado, substituir blocos e consultar a posição do cursor.
• Implementação de Produção: TRadIAOTAEditorAdapter encapsula as chamadas complexas e síncronas da ToolsAPI.
• Implementação de Teste: TMockEditorAdapter simula um buffer de texto puro em memória.

Graças a esse desacoplamento, conseguimos escrever testes automatizados offline para o helper de edição (RadIA.OTA.Helper.pas). Agora validamos de forma robusta ações como:

• Inserção de cabeçalhos de documentação XML (/// <summary>).
• Geração automática de esqueleto de métodos Pascal a partir de comentários.
• Extração e otimização de consultas SQL localizadas sob o cursor.

// Exemplo da declaração da nova interface do Adapter
IRadIAEditorAdapter = interface
  ['{B3E280C5-5D06-44DF-A465-4CE3D7A41FA0}']
  function GetSelectedText: string;
  function GetActiveUnitContent: string;
  procedure ReplaceSelection(const AText: string);
  procedure InsertText(const AText: string);
  function GetCursorLine: Integer;
end;

2. Testes de Aborto Assíncrono e Cancelamento de Rede

O Rad IA executa requisições HTTP assíncronas (streaming de tokens da IA) em threads de background acopladas ao processo principal da IDE (bds.exe). Se o usuário clica em “Parar” ou a rede falha, a thread precisa liberar a conexão de forma segura e imediata para evitar congelamentos na IDE. Para validar isso, implementamos simulação física de latência e aborto assíncrono no mock do client HTTP. Criamos o teste unitário TestProviderBase_CancellationAndTimeout, que valida:

• O comportamento de cancelamento imediato após o recebimento do primeiro chunk.
• A destruição correta de conexões de streaming pendentes.
• O término limpo das threads em segundo plano sem vazamentos de memória (memory leaks) ou Access Violations.

Conclusão: Resultados Sólidos

Com a aplicação desses padrões, atingimos marcos impressionantes de engenharia:

• 268 testes unitários automatizados rodando e passando 100% de forma offline.
• 84,5% de cobertura de código geral (com 100% de cobertura em units críticas de dados).
• Quality Gate do SonarQube aprovado (OK) com 0 novos code smells ou bugs na nova arquitetura.

Essa evolução prova que o Delphi é perfeitamente compatível com as melhores práticas de Clean Code, SOLID e testes automatizados modernos, resultando em um plugin extremamente estável, leve e confiável para o desenvolvedor no dia a dia da IDE.

Acompanhe as atualizações do projeto e contribua no nosso repositório no GitHub!

Gostou do artigo? Deixe seu comentário contando como você lida com testes de integração e acoplamento de APIs na IDE do Delphi!