Guia

Simule uma resposta de API em um dispositivo real

Responda a uma das chamadas de API do seu app com uma resposta pronta — no celular na sua mão, sem servidor falso e sem recompilar. Uma regra de bloqueio Mock para um corpo fixo, um limite de execuções quando ela precisa disparar exatamente uma vez, e um script quando o corpo precisa ser calculado.

Fazer mock em um dispositivo real é onde a maioria das configurações desmorona: o servidor de teste fica em um notebook, o celular precisa alcançá-lo e o app precisa apontar para ele. O Busymate DevTools coloca o mock dentro do caminho de captura. Uma regra de bloqueio observa toda requisição que casa com um método e um padrão de host mais caminho, e responde ela mesma à correspondência — um erro sintético, uma conexão derrubada ou um sucesso simulado que parece exatamente uma resposta da origem. O servidor upstream nunca é contatado.

As regras são aplicadas em dois lugares, então todos os modos de conexão estão cobertos: o servidor proxy para navegadores, Android via proxy e iOS em modo PAC, e o túnel VPN no dispositivo para iOS em modo VPN. Regras globais valem para todos os dispositivos; regras por dispositivo se somam a elas. As alterações se propagam por Realtime, então uma regra que você salva está ativa no celular sem reconexão.

Antes de começar

O que você precisa

Um celular que já está capturando e o endpoint que você quer falsear.

  • Um celular pareado com a captura ligada — siga antes o guia do iPhone ou do Android.

  • O host da API na lista de SSL proxy daquele dispositivo. Uma regra que casa por caminho só enxerga o caminho em um host descriptografado.

  • O método, o host e o caminho da chamada que você quer responder, e o corpo que seu app espera de volta.

  • Só para a variante com script: a capacidade de scripts de nível administrador no seu papel. Regras Mock simples não exigem papel especial.

Passo a passo

Faça na ordem

Os passos um a quatro entregam um mock fixo. O cinco e o seis cobrem os dois casos que um corpo fixo não resolve: disparar uma única vez e calcular a resposta.

  1. 01

    Garanta que o host está descriptografado

    Abra o feed do dashboard e encontre uma requisição real para o endpoint. Se a linha dela mostra um corpo descriptografado, você está pronto. Se o host ainda aparece criptografado, adicione-o à lista de SSL proxy do dispositivo — pelas ações de host da linha ou nas configurações do dispositivo — e dispare a chamada de novo. Em um host que passa criptografado, o motor só consegue casar pelo nome do host; o caminho é invisível, então um mock preciso por caminho nunca dispara.

  2. 02

    Abra Blocks e adicione uma regra

    Abra a página Blocks pelo menu de configurações para uma regra global, ou vá ao dispositivo e depois em Blocks para uma regra que vale só para este celular. Adicione uma regra e preencha o método — ou deixe vazio para casar com qualquer um — e o padrão. Os padrões são os mesmos curingas de host mais caminho usados pelos breakpoints: o host, uma barra, o caminho, com um asterisco onde um segmento varia.

  3. 03

    Escolha Mock e modele a resposta

    Defina a ação como Mock. Enquanto Block serve para fazer uma chamada falhar e Drop faz parecer que a rede sumiu, Mock serve para satisfazê-la: defina o status — o padrão é 200 —, os cabeçalhos que o app vai olhar e o corpo. Dê a ele o Content-Type que seu app interpreta; um cliente JSON que recebe uma resposta em texto falha antes de ler um byte. Salva como JSON, a regra fica assim.

    Uma regra Mock que responde a uma chamada de feature flags com um corpo fixo
    json
    {
      "enabled": true,
      "method": "GET",
      "pattern": "api.example.com/v1/feature-flags",
      "action": {
        "type": "mock",
        "status": 200,
        "headers": { "Content-Type": "application/json" },
        "body": "{\"flags\": {\"newCheckout\": true}}"
      }
    }
  4. 04

    Salve, dispare a chamada e confira o feed

    Salve a regra e use o app. A próxima requisição correspondente é respondida sem nunca sair do caminho de captura, e ainda aparece no seu feed — marcada como simulada, para você ver exatamente o que foi falseado e confirmar que a regra fez o que esperava. O app vê só uma resposta comum de servidor: respostas sintéticas não carregam nenhum cabeçalho interno ou identificador, então nada na resposta revela a interceptação.

    Desligue a regra pela chave de ativação quando terminar. Uma regra desativada não custa nada e mantém seu formato para a próxima vez.

  5. 05

    Dispare exatamente uma vez com um limite de execuções

    Alguns mocks precisam acontecer uma vez só. O caso clássico é um 401 sintético que faz o app acreditar que o token expirou para ele rodar o fluxo de renovação — responda assim a toda requisição e o app renova, tenta de novo, recebe outro 401 e gira para sempre. O campo Max runs limita quantas vezes uma regra pode disparar; ao atingir o limite ela se desativa sozinha e o editor mostra um selo de autodesativada, diferente de uma regra que você mesmo desligou.

    A contagem é por dispositivo e sobrevive a reconexões e reinícios do app, então um limite de um dispara uma única vez naquele celular, não uma vez por sessão. Uma regra global com limite é suprimida só no dispositivo que o gastou e continua disparando em todos os outros celulares da frota. Você também pode pedir ao BusyBro, em linguagem natural, um mock 401 de uma vez só em um host, e ele escreve a mesma regra.

    O 401 de disparo único — idêntico a um mock normal mais um limite de um
    json
    {
      "enabled": true,
      "method": "GET",
      "pattern": "api.example.com/v1/me",
      "action": {
        "type": "mock",
        "status": 401,
        "headers": { "Content-Type": "application/json" },
        "body": "{\"error\": \"token_expired\"}"
      },
      "maxRuns": 1
    }
  6. 06

    Calcule o corpo com um script

    Um corpo Mock é uma string congelada. Quando a resposta precisa depender da requisição — um id devolvido, um timestamp, um campo alterado na resposta real — mude a ação da regra para Script, ou crie um script independente em Settings e depois Scripts. Você tem um editor de código com autocompletar para os objetos de requisição, resposta e auxiliares, e um painel Test que roda seu script contra uma entrada capturada real e mostra um diff de antes e depois sem tocar no tráfego ao vivo. O teste a seco usa o sandbox idêntico ao do proxy ao vivo, então passar no teste significa funcionar em produção.

    Um script que lança erro ou estoura o tempo falha aberto: os bytes originais são encaminhados e a entrada é marcada no inspetor, então um script quebrado nunca trava uma conexão nem se revela ao app. Scripts são de nível administrador porque executam código arbitrário no caminho de captura.

    Um hook de requisição que atalha com um corpo JSON calculado
    javascript
    function onRequest(req) {
      if (req.path.startsWith("/v1/feature-flags")) {
        // computed per request — the upstream is never contacted
        return Response.json({ flags: { newCheckout: true, seed: Date.now() } }, { status: 200 });
      }
      // no return → forward unchanged
    }

Solução de problemas

O que pode dar errado

Uma regra que parece morta quase sempre está tentando casar com algo que não consegue ver.

  • A regra nunca dispara

    Confira se o host está descriptografado para aquele dispositivo — um padrão de caminho precisa disso —, depois confira a grafia do padrão e se o método casa ou está vazio. A linha do feed da requisição real mostra o host e o caminho exatos para copiar.

  • O app ficou preso em um loop de renovação

    Seu 401 sintético dispara em toda requisição. Defina Max runs como um para que a regra se desative após o primeiro acerto e a requisição repetida chegue ao servidor real.

  • O app rejeita a resposta simulada

    Normalmente falta o cabeçalho Content-Type ou o formato do corpo não bate com o que o cliente interpreta. Copie os cabeçalhos e o corpo de uma resposta real capturada no inspetor como ponto de partida.

  • A regra mostra um selo de autodesativada

    Ela gastou o limite de execuções neste dispositivo. Limpe o Max runs ou reative a regra para armá-la de novo.

  • O script rodou, mas a resposta foi a real

    O script lançou erro ou estourou o tempo e falhou aberto. Abra a entrada no inspetor — o selo de erro traz a mensagem e a linha —, corrija no editor e rode o painel Test de novo contra a mesma entrada antes de reativá-lo.

Perguntas frequentes

Perguntas que as pessoas fazem

O app consegue perceber que foi simulado?

Não inspecionando a resposta. Um 200 simulado ou um 403 bloqueado não carrega nenhum cabeçalho identificador e parece uma resposta comum da origem. A visibilidade é de mão única: a entrada marcada aparece só no seu feed.

Isso funciona no iOS em modo VPN ou só pelo proxy?

Nos dois. O mesmo motor de regras roda dentro do túnel VPN do iOS e no servidor proxy, então iOS em qualquer modo, Android pelo proxy e navegadores todos respeitam a regra.

Preciso fazer deploy de alguma coisa quando altero uma regra?

Não. As regras vivem nas mesmas configurações que fluem para os dispositivos por Realtime, então um salvamento se aplica imediatamente a novas conexões. Uma conexão keep-alive já aberta mantém a configuração com que começou até reconectar.

Falseie a resposta, mantenha o celular real

Uma regra no dashboard, e o app na sua mão recebe a resposta que você quer testar — sem servidor de teste, sem recompilar.

Ask your mate