Unlike mocks, artificial implementations give us full command over all of our dependencies in product examinations, allowing all of us to precisely and thoroughly check reactive passes.

At OkCupid, we quite often utilize the Mockito collection for producing mocks of one’s dependencies to be used within our JUnit exams. This permits all of us to conveniently mock return standards beyond doubt methods, or perhaps to validate a way escort Rochester ended up being labeled as using one in our dependencies, however it provides issues because the integration within element under ensure that you their dependencies are more complex.

On this page, we’re likely to walk through a limitation discovered using a mocking library, and discuss how exactly we could work through that limitation simply by using our very own artificial execution. Let’s start with setting the phase when it comes down to issue.

Position The Level

Before we discuss the issue, let’s make sure we understand the component under test. We’ll be looking at a ViewModel which in charge of creating a network request and showing some effects.

Lower is the snippet for any ViewModel, in case you’d like to see the related sessions, you will find them contained in this gist. Observe that in this ViewModel, as soon as it’s developed, we request profile details inside the init approach:

Whenever our very own ViewModel is generated, we’ll produce a loading county to our LiveData. Subsequently, we’ll consult a profile, and post a fresh ProfileViewState when the call succeeds or fails.

It is everything we truly need in regards to our aspect under test. Next we can test drive it.

Testing The ViewModel

We’ll start off with one positive case examination to make sure that as soon as we ask a person, a loading state is actually emitted accompanied by an information state. Let’s see what that test appears to be:

If you’d want to see the utilization of .testObserver() you’ll find it inside gist .

The Test Fails

To the shock, this test will give up! Our company is mocking an effective facts consult, therefore we should count on that our observedStates has actually two records: one the running state, plus one the effective data state. Upon working the test, the initial assertion fails. Our very own examination states that observedStates.size is the one, and also the appreciate will be the information state.

To phrase it differently, the test had not been in a position to examine that a loading state happened.

What Happened?

Let’s think of what’s various in our product test than genuine rule. Inside our unit examination, we’re passing Scheduler.trampoline() from RxJava which helps to help make the community demand run like they were sequential. Regarding this test, it is as though the community consult succeeds quickly after the ViewModel is done.

Subsequently, after the ViewModel is done, we apply an examination observer about ViewModel.state LiveData, and that’s already in a loaded facts condition. This means the running condition taken place too far back the full time – we cannot observe a LiveData earlier’s created, and we’ve no way to verify a loading condition actually ever taken place.

This complication is actually caused by the mocking collection, which tells the mock repository to go back information at once. Instead, we are able to establish our very own fake utilization of a ProfileRepository we have full control over, and will controls that emission of information to ensure our very own device test captures the running condition.

Promoting A Fake

To create a phony execution, we begin by generating a unique course that implements all of our software. Remember, we don’t desire the phony to come back data quickly, because that will just cause the same issue. Rather, since we’re utilizing RxJava, we are able to apply our fake in a way that utilizes a BehaviorSubject behind the scenes that we can get a grip on.

The execution you employ here may change if you work with coroutines, although concept continues to be the exact same: we don’t wanna come back from fetchProfile() with information overnight. We should make certain that the phony execution manages correctly whenever that information is emitted.

Managing Facts Pollutants

Since our very own phony implementation is using a BehaviorSubject once the underlying data source, we can write our personal public solution to emit to it if we including:

Updating Assessments To Validate Running County

Since we’ve a system in position where we fine-grained control of whenever information is produced from our repository, we could leverage this to accurately sample the loading condition. We’ll stick to this meal:

1. Create our very own artificial repository and ViewModel element
2. Since our artificial will not produce facts straight away, we are in a position to validate that people come into a running state.
3. We can get a grip on the fake execution to give off data.
4. Last, we are able to confirm our ViewModel is now in a loaded information state.

Recap

Mocking libraries incorporate a quick answer for generating dependencies to utilize within our Android os unit tests, but come at the cost of creating restrictions for controlling the behavior of those dependencies. By leverage interfaces and our own phony implementation that is out there within laws base, we’ve complete control of the dependencies and now we may use that to control the emission of information for reactive passes to thoroughly unit check all of our elements.

I really hope your found this useful! If you have other types of making use of a fake vs a mock, inform me on Twitter.

Contemplating doing work for OkCupid? We’re hiring!