How to test observer? - unit-testing

Question

I would test presenter like this:
class MostPopularPresenter #Inject constructor(val mostPopularUseCase: MostPopularUseCase)
: Presenter<MostPopularView>() {
fun requestMostPopular(page: Int, update: Boolean) {
if (page <= 6)
mostPopularUseCase.execute(MostPopularObserver(), MostPopularUseCase.Params.createQuery(page, 15, update))
}
inner class MostPopularObserver : DisposableSingleObserver<MostPopularModel>() {
override fun onSuccess(t: MostPopularModel) {
this#MostPopularPresenter.view?.populateRecyclerList(t)
}
override fun onError(e: Throwable) {
this#MostPopularPresenter.view?.showError()
}
}
}
I have problem how to mock observer and force it to throw error or return value on success. I'm using mockito/junit. Can someone point me how to achieve it? Maybe my code is untestable?

Answer 1

An observer is an object that shouldn't be really tested. It has been already tested when it has been developed by a third developer, although there are some people that say, with a part of reason, that you should also test a third party library in order to ensure that it doesn't break your code between versions.
So, if you don't test the observer... how do you test your code? Simply, what you really need to test is the presenter itself. The code running inside the observer is part of the presenter. So instead of mocking the observer mock the useCase:
test useCaseFails() {
val usecase = // mock use case
when(usecase.execute(...))
.thenAnswer(/* receive the observer as first parameter
and make it emit an error */)
val presenter = ...
presenter.requestMostPopular(...)
// assert that presenter.view?.showError has been called
}
Another way of doing this (at least this is the way I usually code) is to make the useCase return an observable and subscribe it in the presenter:
class MostPopularPresenter #Inject constructor(val mostPopularUseCase: MostPopularUseCase)
: Presenter<MostPopularView>() {
private var lateinit observer : Disposable
fun requestMostPopular(page: Int, update: Boolean) {
if (page <= 6)
disposable = mostPopularUseCase.execute(MostPopularUseCase.Params.createQuery(page, 15, update))
.subscribe(t -> view?.populateRecyclerList(t),
e -> view?.showError())
}
}
This way you can easily mock your useCase so it returns a Subject you can control:
test useCaseFails() {
val usecase = // mock use case
val subject = PublishSubject()
when(usecase.execute(...))
.thenReturn(subject)
val presenter = ...
presenter.requestMostPopular(...)
subject.emitError(...) // <- pseudocode
// assert that presenter.view?.showError has been called
}

Answer 2

Usually there are not many cases where it is absolutely not possible to test. As far as I see it, you have a few options:
Put the observer into the constructor with a default value (but this might have some downsides with your dependency injection)
Put the observer into the function with a default value. This would work, but you have to choose if your API should contain this
Use the observer as property. In the test you can override this one.
All this variants would work and are listed here:
// observer in constructor
class MostPopularPresenter #Inject constructor(val mostPopularUseCase: MostPopularUseCase, val observer: DisposableSingleObserver<MostPopularModel> = MostPopularObserver())
: Presenter<MostPopularView>() {
// observer as property
internal var observer: DisposableSingleObserver<MostPopularModel> = MostPopularObserver()
// observer in function
fun requestMostPopular(page: Int, update: Boolean, observer: DisposableSingleObserver<MostPopularModel> = MostPopularObserver()) {
if (page <= 6)
mostPopularUseCase.execute(observer, MostPopularUseCase.Params.createQuery(page, 15, update))
}
}
internal class MostPopularObserver : DisposableSingleObserver<MostPopularModel>() { ... }
It would be even nicer, if you us a DisposableSingleObserverFactory and create the observer when it's needed.
class MostPopularPresenter #Inject constructor(val mostPopularUseCase: MostPopularUseCase, val observerFactory: DisposableSingleObserverFactory<MostPopularModel> = MostPopularObserverFactorty())
: Presenter<MostPopularView>() {
internal var observerFactory: DisposableSingleObserverFactory<MostPopularModel> = MostPopularObserverFactory()
fun requestMostPopular(page: Int, update: Boolean, observerFactory: DisposableSingleObserverFactory<MostPopularModel> = MostPopularObserver()) {
if (page <= 6)
mostPopularUseCase.execute(observerFactory.create(), MostPopularUseCase.Params.createQuery(page, 15, update))
}
}
internal class MostPopularObserver : DisposableSingleObserver<MostPopularModel>() {