Guida

Simula una risposta API su un dispositivo reale

Rispondi a una delle chiamate API della tua app con una risposta predefinita — sul telefono che hai in mano, senza server finto e senza ricompilare. Una regola di blocco Mock per un body fisso, un limite di esecuzioni quando deve scattare esattamente una volta, e uno script quando il body va calcolato.

Il mock su un dispositivo reale è il punto in cui la maggior parte delle configurazioni crolla: il server finto vive su un portatile, il telefono deve raggiungerlo e l'app deve puntare a quello. Busymate DevTools mette invece il mock direttamente nel percorso di cattura. Una regola di blocco osserva ogni richiesta che corrisponde a un metodo e a un pattern host più percorso, e risponde da sola alla corrispondenza — un errore sintetico, una connessione interrotta o un successo simulato che sembra esattamente una risposta dell'origine. Il server upstream non viene mai contattato.

Le regole vengono applicate in due punti, quindi ogni modalità di connessione è coperta: il server proxy per browser, Android via proxy e iOS in modalità PAC, e il tunnel VPN sul dispositivo per iOS in modalità VPN. Le regole globali valgono per ogni dispositivo; quelle per dispositivo si sommano. Le modifiche si propagano via Realtime, quindi una regola salvata è attiva sul telefono senza riconnessione.

Prima di iniziare

Cosa ti serve

Un telefono che sta già catturando e l'endpoint che vuoi falsificare.

  • Un telefono associato con la cattura attiva — segui prima la guida per iPhone o Android.

  • L'host dell'API nella lista SSL proxy di quel dispositivo. Una regola che corrisponde su un percorso vede il percorso solo su un host decifrato.

  • Metodo, host e percorso della chiamata a cui vuoi rispondere, e il body che la tua app si aspetta.

  • Solo per la variante script: la capacità scripts di livello amministratore nel tuo ruolo. Le regole Mock semplici non richiedono alcun ruolo speciale.

Passo dopo passo

Fallo in ordine

I passaggi da uno a quattro ti danno un mock fisso. Il cinque e il sei coprono i due casi che un body fisso non può gestire: scattare una sola volta e calcolare la risposta.

  1. 01

    Assicurati che l'host sia decifrato

    Apri il feed della dashboard e trova una richiesta reale verso l'endpoint. Se la sua riga mostra un body decifrato, sei pronto. Se l'host risulta ancora cifrato, aggiungilo alla lista SSL proxy del dispositivo — dalle azioni host della riga o nelle impostazioni del dispositivo — e riattiva la chiamata. Su un host che passa cifrato il motore può corrispondere solo sul nome host; il percorso è invisibile, quindi un mock preciso sul percorso non scatta mai.

  2. 02

    Apri Blocks e aggiungi una regola

    Apri la pagina Blocks dal menu delle impostazioni per una regola globale, oppure vai sul dispositivo e poi su Blocks per una regola valida solo per questo telefono. Aggiungi una regola e compila il metodo — o lascialo vuoto per corrispondere a qualsiasi — e il pattern. I pattern sono gli stessi caratteri jolly host più percorso usati dai breakpoint: l'host, una barra, il percorso, con un asterisco dove un segmento varia.

  3. 03

    Scegli Mock e modella la risposta

    Imposta l'azione su Mock. Dove Block serve a far fallire una chiamata e Drop fa sembrare che la rete sia sparita, Mock serve a soddisfarla: imposta lo stato — il predefinito è 200 —, gli header che l'app guarderà e il body. Dagli il Content-Type che la tua app interpreta; un client JSON che riceve una risposta di testo fallisce prima di leggere un byte. Salvata come JSON, la regola appare così.

    Una regola Mock che risponde a una chiamata di feature flag con un body fisso
    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

    Salva, attiva la chiamata e controlla il feed

    Salva la regola e usa l'app. La prossima richiesta corrispondente riceve risposta senza mai lasciare il percorso di cattura, e compare comunque nel tuo feed — contrassegnata come simulata, così vedi esattamente cosa è stato falsificato e confermi che la regola ha fatto ciò che ti aspettavi. L'app vede solo una normale risposta del server: le risposte sintetiche non portano alcun header interno o identificativo, quindi nulla nella risposta rivela l'intercettazione.

    Disattiva la regola con il suo interruttore quando hai finito. Una regola disattivata non costa nulla e mantiene la sua forma per la prossima volta.

  5. 05

    Falla scattare esattamente una volta con un limite di esecuzioni

    Alcuni mock devono avvenire una volta sola. Il caso classico è un 401 sintetico che fa credere all'app che il token sia scaduto, così avvia il flusso di refresh — rispondi così a ogni richiesta e l'app aggiorna, riprova, riceve un altro 401 e gira all'infinito. Il campo Max runs limita quante volte una regola può scattare; raggiunto il limite si disattiva da sola e l'editor mostra un badge di autodisattivazione, distinto da una regola che hai spento tu.

    Il conteggio è per dispositivo e sopravvive a riconnessioni e riavvii dell'app, quindi un limite di uno scatta una sola volta in assoluto su quel telefono, non una volta per sessione. Una regola globale con limite viene sospesa solo sul dispositivo che lo ha esaurito e continua a scattare su ogni altro telefono della flotta. Puoi anche chiedere a BusyBro in linguaggio naturale un mock 401 una tantum su un host, e scriverà la stessa regola.

    Il 401 a colpo singolo — identico a un mock normale più un limite di uno
    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

    Calcola il body con uno script

    Un body Mock è una stringa congelata. Quando la risposta deve dipendere dalla richiesta — un id restituito, un timestamp, un campo modificato nella risposta reale — cambia l'azione della regola in Script, oppure crea uno script autonomo in Settings e poi Scripts. Hai un editor di codice con completamento automatico per gli oggetti richiesta, risposta e helper, e un pannello Test che esegue lo script su una voce catturata reale e mostra un diff prima-dopo senza toccare il traffico live. La prova a secco usa la stessa sandbox del proxy live, quindi superare il test significa che funziona dal vivo.

    Uno script che genera un errore o va in timeout fallisce in modo aperto: i byte originali vengono inoltrati e la voce viene contrassegnata nell'inspector, così uno script rotto non può mai bloccare una connessione né rivelarsi all'app. Gli script sono di livello amministratore perché eseguono codice arbitrario nel percorso di cattura.

    Un hook di richiesta che cortocircuita con un body JSON calcolato
    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
    }

Risoluzione dei problemi

Cosa può andare storto

Una regola che sembra morta quasi sempre cerca di corrispondere a qualcosa che non può vedere.

  • La regola non scatta mai

    Controlla che l'host sia decifrato per quel dispositivo — un pattern di percorso ne ha bisogno —, poi l'ortografia del pattern e che il metodo corrisponda o sia vuoto. La riga del feed della richiesta reale mostra host e percorso esatti da copiare.

  • L'app è rimasta bloccata in un ciclo di refresh

    Il tuo 401 sintetico scatta a ogni richiesta. Imposta Max runs a uno così la regola si disattiva dopo il primo colpo e la richiesta ripetuta raggiunge il server reale.

  • L'app rifiuta la risposta simulata

    Di solito manca l'header Content-Type oppure la forma del body non corrisponde a ciò che il client interpreta. Copia header e body di una risposta reale catturata dall'inspector come punto di partenza.

  • La regola mostra un badge di autodisattivazione

    Ha esaurito il limite di esecuzioni su questo dispositivo. Azzera Max runs o riattiva la regola per armarla di nuovo.

  • Lo script è stato eseguito ma la risposta era quella reale

    Lo script ha generato un errore o è andato in timeout ed è fallito in modo aperto. Apri la voce nell'inspector — il badge di errore riporta messaggio e riga —, correggi nell'editor e riesegui il pannello Test sulla stessa voce prima di riattivarlo.

FAQ

Le domande più frequenti

L'app può accorgersi di essere stata simulata?

Non ispezionando la risposta. Un 200 simulato o un 403 bloccato non porta alcun header identificativo e sembra una normale risposta dell'origine. La visibilità è a senso unico: la voce contrassegnata compare solo nel tuo feed.

Funziona su iOS in modalità VPN o solo tramite il proxy?

Entrambi. Lo stesso motore di regole gira dentro il tunnel VPN di iOS e sul server proxy, quindi iOS in entrambe le modalità, Android via proxy e i browser rispettano tutti la regola.

Devo rifare il deploy di qualcosa quando cambio una regola?

No. Le regole vivono nelle stesse impostazioni che fluiscono ai dispositivi via Realtime, quindi un salvataggio si applica subito alle nuove connessioni. Una connessione keep-alive già aperta mantiene la configurazione con cui è partita finché non si riconnette.

Falsifica la risposta, tieni il telefono reale

Una regola nella dashboard, e l'app che hai in mano riceve la risposta che vuoi testare — senza server finto, senza ricompilare.

Ask your mate