Como Migrar do ReadyAPI para Apidog: Guia Completo

TL;DR

A migração do ReadyAPI para o Apidog é simples para conjuntos de testes que usam predominantemente REST. Exporte seu projeto ReadyAPI, converta o que puder via importação OpenAPI e recrie manualmente scripts Groovy em JavaScript. Casos de teste SOAP exigem o maior trabalho manual. Planeje uma migração faseada para manter a cobertura de testes contínua.

💡 Apidog é uma plataforma de desenvolvimento de API gratuita e completa que importa especificações OpenAPI e coleções Postman, e executa pipelines de teste com scripts JavaScript. Experimente o Apidog gratuitamente, sem necessidade de cartão de crédito.

Experimente o Apidog hoje

Introdução

Migrar a infraestrutura de testes de API pode parecer simples, mas envolve várias etapas e decisões técnicas. Projetos ReadyAPI geralmente acumulam anos de casos de teste, scripts Groovy personalizados, arquivos de dados, ambientes e estruturas de testes complexas. Para migrar tudo para o Apidog, é fundamental saber o que pode ser transferido automaticamente, o que exige conversão manual e o que pode ser descartado.

Este guia mostra um processo prático de migração passo a passo, incluindo exportação do ReadyAPI, análise do projeto, importação para o Apidog, conversão de scripts Groovy para JavaScript, setup de CI/CD e como operar as ferramentas em paralelo durante a transição.

Passo 1: Audite seu projeto ReadyAPI antes de começar

1. Conte conjuntos, casos e etapas de teste: No painel Navegador do ReadyAPI, conte quantos conjuntos e casos de teste você possui. Projetos pequenos migram em horas; grandes, em dias.
2. Classifique o tipo de teste (REST ou SOAP): Testes REST migram mais facilmente. SOAP requer mais trabalho manual, principalmente com WS-Security e asserções complexas.
3. Identifique scripts Groovy: Procure etapas de Script nos casos de teste. Cada script Groovy precisará ser convertido manualmente para JavaScript.
4. Verifique uso de testes orientados a dados (DataSource): O Apidog suporta testes com CSV e JSON, mas sua configuração é diferente do padrão DataSource/DataSink do ReadyAPI.
5. Localize etapas Properties/Property Transfer: Estes padrões são substituídos por variáveis e variáveis de ambiente no Apidog.
6. Testes de carga (LoadUI Pro): Não são migrados. Planeje usar k6 ou outra ferramenta para cenários de carga.

Documente tudo em uma planilha: nome do caso de teste, tipo (REST/SOAP), usa Groovy (sim/não) e complexidade. Isso define o escopo da migração.

Passo 2: Exporte seu projeto ReadyAPI

1. Abra o ReadyAPI e carregue seu projeto.
2. Vá em Arquivo > Salvar Como e salve o projeto como XML.
3. Salve arquivos de dados externos (CSV, Excel, XML) referenciados nos testes.
4. Anote as configurações dos ambientes.

O arquivo XML contém todos os conjuntos de testes, casos, etapas, scripts e configs do seu projeto.

Passo 3: Extraia suas definições de API

O caminho mais limpo para migrar APIs REST é via especificação OpenAPI.

• A) Exportar do ReadyAPI: Clique com o direito sobre o serviço REST no Navegador e exporte a especificação Swagger/OpenAPI.
• B) Usar OpenAPI do backend: Se sua API já expõe um /openapi.json, baixe direto.
• C) Extrair manualmente: Se não há especificação, anote endpoints, bodies, headers e responses das requests do ReadyAPI para recriar no Apidog.

Passo 4: Importe para o Apidog

1. Abra o Apidog e crie um novo projeto.
2. Vá em APIs > Importar e selecione o formato (OpenAPI 3.0, Swagger 2.0, etc).
3. Faça upload do arquivo ou informe a URL da especificação.
4. O Apidog criará todas as definições de endpoints, parâmetros, bodies e respostas automaticamente.

Se você possui coleções Postman, também pode importar via Arquivo > Importar > Postman.

Passo 5: Recrie casos de teste para endpoints REST

Para cada caso de teste REST:

1. Abra o caso de teste no ReadyAPI e identifique requests, asserções e fontes de dados.
2. No Apidog, crie o caso de teste correspondente selecionando o endpoint e adicionando etapas de teste.
3. Traduza as asserções:

• "Contém" (body contém string):
  

  pm.test('contains value', () => {
    pm.expect(pm.response.text()).to.include('expected string');
  });
  

• Código de status:
  

  pm.test('status 200', () => {
    pm.response.to.have.status(200);
  });
  

• JSONPath:
  

  pm.test('field value', () => {
    pm.expect(pm.response.json().fieldName).to.equal('expected');
  });
  

Testes simples (GET/POST sem Groovy) podem ser recriados em 15 a 30 minutos por caso.

Passo 6: Converta scripts Groovy para JavaScript

Scripts Groovy exigem conversão manual. Veja exemplos práticos de conversão:

• Lendo valor de resposta:
  

  // Groovy (ReadyAPI)
  def response = context.expand('${TestStep#Response}')
  def json = new groovy.json.JsonSlurper().parseText(response)
  def value = json.fieldName
  

```javascript
// JavaScript (Apidog)
const response = pm.response.json();
const value = response.fieldName;
```

• Definindo variável:
  

  // Groovy
  testRunner.testCase.setPropertyValue('myVariable', someValue)
  

```javascript
// JavaScript
pm.variables.set('myVariable', someValue);
```

• Asserção condicional:
  

  // Groovy
  if (statusCode == 200) {
    assert responseBody.contains("success")
  }
  

```javascript
// JavaScript
if (pm.response.code === 200) {
  pm.test('response contains success', () => {
    pm.expect(pm.response.text()).to.include('success');
  });
}
```

• Manipulação de data:
  

  // Groovy
  def now = new Date()
  def formatted = now.format('yyyy-MM-dd')
  

```javascript
// JavaScript
const now = new Date();
const formatted = now.toISOString().split('T')[0];
```

Para scripts Groovy complexos, leia e compreenda sua lógica antes de reescrever em JavaScript. Evite traduções automáticas.

Passo 7: Lide com casos de teste SOAP

O Apidog não tem suporte nativo para SOAP. Suas opções:

• Se o serviço SOAP também expõe REST: Migre os testes para REST.
• Se não há REST:
  • Mantenha o ReadyAPI apenas para SOAP: Execute ReadyAPI em paralelo exclusivamente para esses casos.
  • Use SoapUI Open Source: Para testes SOAP funcionais básicos.

Migrações SOAP exigem atenção, especialmente para WS-Security e asserções específicas.

Passo 8: Configure ambientes e variáveis

1. Crie ambientes no Apidog em Configurações > Ambientes, equivalentes aos do ReadyAPI.
2. Adicione as mesmas variáveis (URLs base, tokens, headers).
3. Atualize referências nos testes para a sintaxe do Apidog: {{variableName}}.

Passo 9: Configure CI/CD

1. Instale o CLI do Apidog no agente de CI:
   

   npm install -g apidog-cli
   

2. Execute uma coleção de testes:
   

   apidog run "path/to/collection.json" -e "environment-id"
   

3. Exemplo para GitHub Actions:
   

   - name: Run API tests
     run: apidog run collection.json --environment staging
   

4. Para Jenkins, adicione uma etapa shell para chamar o CLI do Apidog.

Atualize os arquivos de configuração de CI para usar o comando do Apidog. Remova o testrunner do ReadyAPI quando a transição estiver completa.

Passo 10: Execute ambas as ferramentas em paralelo durante a transição

Por pelo menos um ciclo de release, rode ReadyAPI e Apidog em paralelo:

• Execute ReadyAPI no CI como referência principal.
• Execute Apidog paralelamente e compare resultados.
• Investigue divergências/falhas.
• Crie novos testes apenas no Apidog.

Quando o Apidog cobrir totalmente os testes, remova o ReadyAPI do pipeline, mas mantenha-o disponível por alguns meses como fallback.

FAQ

Quanto tempo leva uma migração do ReadyAPI para o Apidog?

Projetos apenas REST e com pouco Groovy migram em 1 a 3 dias. Projetos grandes, com muitos scripts, SOAP e estruturas complexas podem levar de 2 a 6 semanas. Faça a auditoria do Passo 1 para estimar.

Meus arquivos de dados de teste do ReadyAPI funcionam no Apidog?

Arquivos CSV funcionam diretamente. Arquivos Excel devem ser convertidos para CSV. XMLs precisam ser reestruturados conforme o uso.

Posso rodar ReadyAPI e Apidog no mesmo pipeline CI durante a migração?

Sim, essa é a abordagem recomendada. Adicione o CLI do Apidog ao seu pipeline e compare os resultados até finalizar a transição.

Preciso recriar ambientes manualmente?

Sim. Não há importação automática dos ambientes do ReadyAPI. Recrie-os manualmente no Apidog.

O que acontece com testes ReadyAPI sem equivalente REST?

Para testes apenas SOAP, mantenha o ReadyAPI (com menos licenças, se possível), migre para SoapUI Open Source ou aceite uma lacuna de teste se o serviço for legado/baixo risco.

O Apidog suporta os mesmos tipos de asserção do ReadyAPI?

O Apidog permite asserções JavaScript equivalentes às do ReadyAPI para REST. Asserções específicas de SOAP (SOAP Fault, WS-Security) não têm equivalente.

---

Migrar do ReadyAPI para o Apidog é um projeto importante. Planeje, audite, migre REST primeiro e rode as duas ferramentas em paralelo para garantir cobertura total de testes e evitar regressões.