lundi 22 mai 2017

How to verify no interactions on RxJava2 Observable using Mockito

Observable is final class, so we can't create mocks for it to verify or capture any interactions performed on it.

And Observable's test(), TestSubscriber also does not provide any such interaction assertion techinque

I have created a generic method for checking cached data before loading from network

/**
 * General parametrized method for loading data from service while checking connection
 * and respecting reload state
 */
private <T> Observable<T> getData(Observable<T> dataSource, String key, boolean reload) {
    T cachedData = (T) cacheModel.getValue(key);

    // Do not use cache if reloading
    if(!reload && cachedData != null)
        return Observable.just(cachedData);

    if(!utilModel.isConnected()) {
        return Observable.error(new Throwable(Constants.NO_NETWORK));
    }

    return dataSource
        .doOnNext(data -> cacheModel.saveObject(key, data))
        .subscribeOn(Schedulers.io())
        .observeOn(AndroidSchedulers.mainThread());
}

And using it as follows:

@Override
public Observable<User> getOrganiser(boolean reload) {
    return getData(eventService.getUser(authorization), ORGANIZER, reload);
}

Before, I was not even calling eventService.getUser(...) to get the observable, so I could test if it was never being called, but now, as I have to pass it to the template method, I need to call it but verify if cache is present, it is never interacted with.

This is my previous test, which is obviously failing now

@Test
public void shouldLoadOrganizerFromCache() {
    // Clear cache
    objectCache.clear();

    User user = new User();
    objectCache.saveObject(RetrofitEventRepository.ORGANIZER, user);

    // No force reload ensures use of cache
    Observable<User> userObservable = retrofitEventModel.getOrganiser(false);

    userObservable.test().assertNoErrors();
    userObservable.test().assertValue(user);

    verify(eventService, never()).getUser(auth);
}

Aucun commentaire:

Enregistrer un commentaire