Server di retrofit quadrato finto per test

Qual è il modo migliore per simulare un server per i test quando si utilizza il framework di retrofit quadrato .

Possibili modi:

1. Crea un nuovo client di retrofit e impostalo in RestAdapter.Builder (). SetClient (). Ciò comporta l'analisi dell'oggetto Request e la restituzione del json come oggetto Response.

2. Implementa questa interfaccia annotata come una classe fittizia e usala al posto della versione fornita da RestAdapter.create () (non testare la serializzazione gson)

3. ?

Idealmente, voglio che il server deriso fornisca risposte json in modo da poter testare la serializzazione gson allo stesso tempo.

Qualsiasi esempio sarebbe molto apprezzato.

Richieste di Mock Retrofit 2.0 per il test

Poiché i vecchi meccanismi come la creazione di MockClientclassi e l'implementazione da cui Clientnon funzionano più con Retrofit 2.0, qui descrivo un nuovo modo di farlo. Tutto quello che devi fare ora è aggiungere i tuoi intercettori personalizzati per OkHttpClient come mostrato di seguito . FakeInterceptorclass sovrascrive solo il interceptmetodo e nel caso in cui l'applicazione sia in DEBUGmodalità restituisce JSON.

RestClient.java

public final class RestClient {

    private static IRestService mRestService = null;

    public static IRestService getClient() {
        if(mRestService == null) {
            final OkHttpClient client = new OkHttpClient();
            // ***YOUR CUSTOM INTERCEPTOR GOES HERE***
            client.interceptors().add(new FakeInterceptor());

            final Retrofit retrofit = new Retrofit.Builder()
                            // Using custom Jackson Converter to parse JSON
                            // Add dependencies:
                            // com.squareup.retrofit:converter-jackson:2.0.0-beta2
                    .addConverterFactory(JacksonConverterFactory.create())
                            // Endpoint
                    .baseUrl(IRestService.ENDPOINT)
                    .client(client)
                    .build();

            mRestService = retrofit.create(IRestService.class);
        }
        return mRestService;
    }
}

IRestService.java

public interface IRestService {

    String ENDPOINT = "http://www.vavian.com/";

    @GET("/")
    Call<Teacher> getTeacherById(@Query("id") final String id);
}

FakeInterceptor.java

public class FakeInterceptor implements Interceptor { 
    // FAKE RESPONSES.
    private final static String TEACHER_ID_1 = "{\"id\":1,\"age\":28,\"name\":\"Victor Apoyan\"}";
    private final static String TEACHER_ID_2 = "{\"id\":1,\"age\":16,\"name\":\"Tovmas Apoyan\"}";

    @Override
    public Response intercept(Chain chain) throws IOException {
        Response response = null;
        if(BuildConfig.DEBUG) {
            String responseString;
            // Get Request URI.
            final URI uri = chain.request().url().uri();
            // Get Query String.
            final String query = uri.getQuery();
            // Parse the Query String.
            final String[] parsedQuery = query.split("=");
            if(parsedQuery[0].equalsIgnoreCase("id") && parsedQuery[1].equalsIgnoreCase("1")) {
                responseString = TEACHER_ID_1;
            }
            else if(parsedQuery[0].equalsIgnoreCase("id") && parsedQuery[1].equalsIgnoreCase("2")){
                responseString = TEACHER_ID_2;
            }
            else {
                responseString = "";
            }

            response = new Response.Builder()
                    .code(200)
                    .message(responseString)
                    .request(chain.request())
                    .protocol(Protocol.HTTP_1_0)
                    .body(ResponseBody.create(MediaType.parse("application/json"), responseString.getBytes()))
                    .addHeader("content-type", "application/json")
                    .build();
        }
        else {
            response = chain.proceed(chain.request());
        }

        return response;
    }
}

Codice sorgente del progetto su GitHub

Ho deciso di provare il metodo 1 come segue

public class MockClient implements Client {

    @Override
    public Response execute(Request request) throws IOException {
        Uri uri = Uri.parse(request.getUrl());

        Log.d("MOCK SERVER", "fetching uri: " + uri.toString());

        String responseString = "";

        if(uri.getPath().equals("/path/of/interest")) {
            responseString = "JSON STRING HERE";
        } else {
            responseString = "OTHER JSON RESPONSE STRING";
        }

        return new Response(request.getUrl(), 200, "nothing", Collections.EMPTY_LIST, new TypedByteArray("application/json", responseString.getBytes()));
    }
}

E usandolo da:

RestAdapter.Builder builder = new RestAdapter.Builder();
builder.setClient(new MockClient());

Funziona bene e ti permette di testare le tue stringhe json senza dover contattare il server reale!

Testare la deserializzazione JSON sui tuoi oggetti (presumibilmente con TypeAdapters?) Sembra un problema separato che richiede unit test separati.

Uso personalmente la versione 2. Fornisce codice indipendente dai tipi e compatibile con il refactor che può essere facilmente sottoposto a debug e modificato. Dopo tutto, a che serve dichiarare la tua API come interfacce se non stai creando versioni alternative di esse per il test! Polimorfismo per la vittoria.

Un'altra opzione è usare Java Proxy. Questo è in realtà il modo in cui Retrofit (attualmente) implementa la sua interazione HTTP sottostante. Ciò richiederà certamente più lavoro, ma consentirebbe simulazioni molto più dinamiche.

Puoi anche usare qualcosa come Webservermock di Squareup! -> https://github.com/square/okhttp/tree/master/mockwebserver

Sono un grande fan di Apiary.io per aver deriso un'API prima di passare a un server reale.

È inoltre possibile utilizzare file .json flat e leggerli dal file system.

Puoi anche utilizzare API pubblicamente accessibili come Twitter, Flickr, ecc.

Ecco alcune altre fantastiche risorse su Retrofit.

Diapositive: https://docs.google.com/presentation/d/12Eb8OPI0PDisCjWne9-0qlXvp_-R4HmqVCjigOIgwfY/edit#slide=id.p

Video: http://www.youtube.com/watch?v=UtM06W51pPw&feature=g-user-u

Progetto di esempio: https://github.com/dustin-graham/ucad_twitter_retrofit_sample

Mockery (disclaimer: I'm the author) è stato progettato proprio per questo compito.

Mockery è una libreria di simulazione / test incentrata sulla convalida dei livelli di rete con supporto integrato per Retrofit. Genera automaticamente i test JUnit in base alle specifiche di una determinata API. L'idea è di non dover scrivere manualmente alcun test; né implementare interfacce per deridere le risposte del server.

1. Per prima cosa, crea la tua interfaccia Retrofit.

   public interface LifeKitServerService {
       /**
        * query event list from server,convert Retrofit's Call to RxJava's Observerable
        *
        * @return Observable<HttpResult<List<Event>>> event list from server,and it has been convert to Obseverable
        */
       @GET("api/event")
       Observable<HttpResult<List<Event>>> getEventList();
   }

2. Il tuo richiedente a seguire:

   public final class HomeDataRequester {
       public static final String TAG = HomeDataRequester.class.getSimpleName();
       public static final String SERVER_ADDRESS = BuildConfig.DATA_SERVER_ADDR + "/";
       private LifeKitServerService mServerService;
   
       private HomeDataRequester() {
           OkHttpClient okHttpClient = new OkHttpClient.Builder()
                   //using okhttp3 interceptor fake response.
                   .addInterceptor(new MockHomeDataInterceptor())
                   .build();
   
           Retrofit retrofit = new Retrofit.Builder()
                   .client(okHttpClient)
                   .baseUrl(SERVER_ADDRESS)
                   .addCallAdapterFactory(RxJavaCallAdapterFactory.create())
                   .addConverterFactory(GsonConverterFactory.create(new Gson()))
                   .build();
   
           //using okhttp3 inteception to fake response.
           mServerService = retrofit.create(LifeKitServerService.class);
   
           //Second choice,use MockRetrofit to fake data.
           //NetworkBehavior behavior = NetworkBehavior.create();
           //MockRetrofit mockRetrofit = new MockRetrofit.Builder(retrofit)
           //        .networkBehavior(behavior)
           //        .build();
           //mServerService = new MockLifeKitServerService(
           //                    mockRetrofit.create(LifeKitServerService.class));
       }
   
       public static HomeDataRequester getInstance() {
           return InstanceHolder.sInstance;
       }
   
       public void getEventList(Subscriber<HttpResult<List<Event>>> subscriber) {
           mServerService.getEventList()
                   .subscribeOn(Schedulers.io())
                   .unsubscribeOn(Schedulers.io())
                   .observeOn(AndroidSchedulers.mainThread())
                   .subscribe(subscriber);
       }
   }

3. Se si utilizza la seconda scelta (utilizzare l'interfaccia Retrofit per i dati del server Mock), è necessario utilizzare MockRetrofit, utilizzare il codice seguente:

   public final class MockLifeKitServerService implements LifeKitServerService {
   public static final String TAG = MockLifeKitServerService.class.getSimpleName();
   private BehaviorDelegate<LifeKitServerService> mDelegate;
   private Gson mGson = new Gson();
   
   public MockLifeKitServerService(BehaviorDelegate<LifeKitServerService> delegate) {
       mDelegate = delegate;
   }
   
   @Override
   public Observable<HttpResult<List<Event>>> getEventList() {
       List<Event> eventList = MockDataGenerator.generateEventList();
       HttpResult<List<Event>> httpResult = new HttpResult<>();
       httpResult.setCode(200);
       httpResult.setData(eventList);
   
       LogUtil.json(TAG, mGson.toJson(httpResult));
   
       String text = MockDataGenerator.getMockDataFromJsonFile("server/EventList.json");
       if (TextUtils.isEmpty(text)) {
           text = mGson.toJson(httpResult);
       }
       LogUtil.d(TAG, "Text:\n" + text);
   
       text = mGson.toJson(httpResult);
   
       return mDelegate.returningResponse(text).getEventList();
   }

4.I miei dati provengono dal file di risorse (Asset / server / EventList.json), il contenuto di questo file è:

    {
      "code": 200,
      "data": [
        {
          "uuid": "e4beb3c8-3468-11e6-a07d-005056a05722",
          "title": "title",
          "image": "http://image.jpg",
          "goal": 1500000,
          "current": 51233,
          "hot": true,
          "completed": false,
          "createdAt": "2016-06-15T04:00:00.000Z"
        }
      ]
    }

5.Se stai usando okhttp3 interceptor, devi auto-definire l'interceptor, in questo modo:

public final class MockHomeDataInterceptor implements Interceptor {
    public static final String TAG = MockHomeDataInterceptor.class.getSimpleName();

    @Override
    public Response intercept(Chain chain) throws IOException {
        Response response = null;

        String path = chain.request().url().uri().getPath();
        LogUtil.d(TAG, "intercept: path=" + path);

        response = interceptRequestWhenDebug(chain, path);
        if (null == response) {
            LogUtil.i(TAG, "intercept: null == response");
            response = chain.proceed(chain.request());
        }
        return response;
    }

    private Response interceptRequestWhenDebug(Chain chain, String path) {
        Response response = null;
        if (BuildConfig.DEBUG) {
            Request request = chain.request();
            if (path.equalsIgnoreCase("/api/event")) {
                //get event list
                response = getMockEventListResponse(request);
            }
    }

    private Response getMockEventListResponse(Request request) {
        Response response;

        String data = MockDataGenerator.getMockDataFromJsonFile("server/EventList.json");
        response = getHttpSuccessResponse(request, data);
        return response;
    }

    private Response getHttpSuccessResponse(Request request, String dataJson) {
        Response response;
        if (TextUtils.isEmpty(dataJson)) {
            LogUtil.w(TAG, "getHttpSuccessResponse: dataJson is empty!");
            response = new Response.Builder()
                    .code(500)
                    .protocol(Protocol.HTTP_1_0)
                    .request(request)
                    //protocol&request be set,otherwise will be exception.
                    .build();
        } else {
            response = new Response.Builder()
                    .code(200)
                    .message(dataJson)
                    .request(request)
                    .protocol(Protocol.HTTP_1_0)
                    .addHeader("Content-Type", "application/json")
                    .body(ResponseBody.create(MediaType.parse("application/json"), dataJson))
                    .build();
        }
        return response;
    }
}

6.Infine, puoi richiedere il tuo server con il codice:

mHomeDataRequester.getEventList(new Subscriber<HttpResult<List<Event>>>() {
    @Override
    public void onCompleted() {

    }

    @Override
    public void onError(Throwable e) {
        LogUtil.e(TAG, "onError: ", e);
        if (mView != null) {
            mView.onEventListLoadFailed();
        }
    }

    @Override
    public void onNext(HttpResult<List<Event>> httpResult) {
        //Your json result will be convert by Gson and return in here!!!
    });
}

Grazie per aver letto.

Aggiungendo alla risposta di @Alec, ho esteso il client fittizio per ottenere la risposta direttamente da un file di testo nella cartella delle risorse a seconda dell'URL della richiesta.

Ex

@POST("/activate")
public void activate(@Body Request reqdata, Callback callback);

Qui il finto client, capisce che l'URL che viene sparato è attivato e cerca un file chiamato Activate.txt nella cartella degli asset. Legge il contenuto dal file assets / activation.txt e lo invia come risposta per l'API.

Ecco l'estensione MockClient

public class MockClient implements Client {
    Context context;

    MockClient(Context context) {
        this.context = context;
    }

    @Override
    public Response execute(Request request) throws IOException {
        Uri uri = Uri.parse(request.getUrl());

        Log.d("MOCK SERVER", "fetching uri: " + uri.toString());

        String filename = uri.getPath();
        filename = filename.substring(filename.lastIndexOf('/') + 1).split("?")[0];

        try {
            Thread.sleep(2500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        InputStream is = context.getAssets().open(filename.toLowerCase() + ".txt");
        int size = is.available();
        byte[] buffer = new byte[size];
        is.read(buffer);
        is.close();
        String responseString = new String(buffer);

        return new Response(request.getUrl(), 200, "nothing", Collections.EMPTY_LIST, new TypedByteArray("application/json", responseString.getBytes()));
    }
}

Per una spiegazione dettagliata puoi controllare il mio blog
http://www.cumulations.com/blogs/13/Mock-API-response-in-Retrofit-using-custom-clients

JSONPlaceholder: API REST online falsa per test e prototipi

https://jsonplaceholder.typicode.com/

ReqresIn: un'altra API REST online

https://reqres.in/

Server finto postino

Se desideri testare il payload di risposta personalizzato, i due precedenti potrebbero non soddisfare le tue esigenze, puoi provare il server fittizio di postino. È abbastanza facile da configurare e flessibile per definire il proprio payload di richiesta e risposta.

https://learning.getpostman.com/docs/postman/mock_servers/intro_to_mock_servers/ https://youtu.be/shYn3Ys3ygE

Deridere le chiamate API con Retrofit è ora ancora più semplice con Mockinizer che rende il lavoro con MockWebServer davvero semplice:

import com.appham.mockinizer.RequestFilter
import okhttp3.mockwebserver.MockResponse

val mocks: Map<RequestFilter, MockResponse> = mapOf(

    RequestFilter("/mocked") to MockResponse().apply {
        setResponseCode(200)
        setBody("""{"title": "Banana Mock"}""")
    },

    RequestFilter("/mockedError") to MockResponse().apply {
        setResponseCode(400)
    }

)

Basta creare una mappa di RequestFilter e MockResponses e quindi collegarla alla catena di builder OkHttpClient:

OkHttpClient.Builder()
            .addInterceptor(loggingInterceptor)
            .mockinize(mocks) // <-- just plug in your custom mocks here
            .build()

Non devi preoccuparti di configurare MockWebServer ecc. Aggiungi semplicemente i tuoi mock, il resto è fatto da Mockinizer per te.

(Dichiarazione di non responsabilità: sono l'autore di Mockinizer)

Per me il client di retrofit personalizzato è ottimo grazie alla flessibilità. Soprattutto quando si utilizza qualsiasi framework DI, è possibile attivare / disattivare in modo rapido e semplice il mock. Sto utilizzando un client personalizzato fornito da Dagger anche nei test di unità e di integrazione.

Modifica: qui trovi un esempio di derisione del retrofit https://github.com/pawelByszewski/retrofitmock