Develop Reference

Android Firebase Junit4 mocking database. How to mock database children?

Need some help with testing my app.
I want to verify viewmodel fun writeNewTask(). It has to add Task object into database under the parents called tasks and personal id of every Task.
fun writeNewTask(name: String?, orphanage: String?) {
val id = database.push().key!!
val task = Task(id, name, orphanage)
database.child("tasks").child(id).setValue(task)
}
I'm using PowerMock. So, that's how my test looks like
#RunWith(PowerMockRunner::class)
#PowerMockRunnerDelegate(JUnit4::class)
#PrepareForTest(FirebaseDatabase::class, AddTaskViewModel::class, DatabaseReference::class)
#PowerMockIgnore("org.mockito.*", "org.robolectric.*", "android.*", "androidx.*")
class AddTaskViewModelTest {
#Mock
lateinit var mockedDatabase: FirebaseDatabase
#Mock
lateinit var databaseReference: DatabaseReference
#Mock
lateinit var viewModel: AddTaskViewModel
#Before
fun before() {
viewModel = PowerMockito.mock(AddTaskViewModel::class.java)
databaseReference = PowerMockito.mock(DatabaseReference::class.java)
PowerMockito.mockStatic(AddTaskViewModel::class.java)
PowerMockito.mockStatic(DatabaseReference::class.java)
PowerMockito.mockStatic(FirebaseDatabase::class.java)
`when`(FirebaseDatabase.getInstance()).thenReturn(mockedDatabase)
mockedDatabase = PowerMockito.mock(FirebaseDatabase::class.java)
`when`(mockedDatabase.reference).thenReturn(databaseReference)
}
#Test
fun writeNewTaskTest() {
val id = "1"
`when`(databaseReference.key).thenReturn(id)
val name = "name"
val orphanage = "orphanage"
val task = Task(id, name, orphanage)
viewModel.writeNewTask(name, orphanage)
verify(databaseReference)
.child("tasks")
.child(id)
.setValue(task)
}
}
And I catch this error. After debugging I figured out that child("tasks") is null
databaseReference.child("tasks");
-> at com.example.application.viewModel.AddTaskViewModelTest.writeNewTaskTest(AddTaskViewModelTest.kt:59)
Actually, there were zero interactions with this mock.
Wanted but not invoked:
databaseReference.child("tasks");
-> at com.example.application.viewModel.AddTaskViewModelTest.writeNewTaskTest(AddTaskViewModelTest.kt:59)
Actually, there were zero interactions with this mock.

This happens because the reference you have to your database is not the same as you have in the ViewModel. So let's pretend you have a ViewModel that gets a database in it's contructor as such:
class AddTaskViewModel(private val database: FirebaseDatabase): ViewModel()
So, to test your ViewModel you need to create its instance, not mock it. Which in your code should look like:
#Before
fun before() {
databaseReference = mock(DatabaseReference::class.java)
mockedDatabase = mock(FirebaseDatabase::class.java)
`when`(mockedDatabase.reference).thenReturn(databaseReference)
viewModel = AddTaskViewModel(mockedDatabase)
}
Also you don't need PowerMockito to test this, Mockito itself is enough

Mockito does'nt mock repository

i'm try to test my ViewModel with mockito.
This is my TestClass:
#RunWith(JUnit4::class)
class RatesViewModelTest {
#Rule #JvmField
open val instantExecutorRule = InstantTaskExecutorRule()
#Mock
var observer: Observer<Pair<ArrayList<CurrencyExchangerModel>,Boolean>>? = null
#Mock
private lateinit var repository: RatesRepository
private var currencyList = ArrayList<CurrencyModel>()
private lateinit var viewModel : RatesViewModel
#Before
fun setUp(){
MockitoAnnotations.initMocks(this)
currencyList.add(CurrencyModel("BASE"))
viewModel = RatesViewModel(repository!!)
viewModel.getCurrencyExchangerObservableList().observeForever(observer!!)
}
#Test
fun testNull(){
Mockito.`when`(repository.getFlowableRates()).thenReturn( Flowable.just(currencyList) )
assertTrue(viewModel.getCurrencyExchangerObservableList().hasObservers())
}
}
When this method is invoked:
Mockito.`when`(repository.getFlowableRates()).thenReturn( Flowable.just(currencyList) )
I got this error:
kotlin.UninitializedPropertyAccessException: lateinit property db has
not been initialized
Here the repository:
open class RatesRepository(context:Context) : BaseRepository(context){
#Inject
lateinit var ratesAPI: RatesAPI
#Inject
lateinit var db: Database
/**
* load the updated chatList from API
*/
fun loadCurrencyRatesFromAPI(): Single<ArrayList<CurrencyModel>> {
val supportedCurrency = context.resources.getStringArray(R.array.currencies)
return ratesAPI.getLatestRates(EUR_CURRENCY_ID).map { RatesConverter.getRatesListFromDTO(it,supportedCurrency) }
}
/**
* save rates on DB
*/
fun saveCurrencyRatesOnDB(list:ArrayList<CurrencyModel>): Completable {
return db.currencyRatesDAO().insertAll(list)
}
/**
* get flawable rates from DB
*/
fun getFlowableRates(): Flowable<List<CurrencyModel>> {
return db.currencyRatesDAO().getAll()
}
companion object {
const val EUR_CURRENCY_ID = "EUR" //BASE
}
}
What i'm doing wrong ?
Thx !

When you define behaviour of a mock and use the when(...).then(...) notation of mockito,
the method itself is invoked (by mockito, normally not relevant for your test).
In your case that is a problem because db is not initialized.
To avoid this issues use the doReturn(...).when(...) syntax in these cases,
which does not cause the method invocation.
Mockito.doReturn(Flowable.just(currencyList)).when(repository).getFlowableRates();
(You might need to adjust this java syntax to make it kotlin compatible)

Espresso UI error on ViewModelProviders.of

I'm trying to write an espresso test in my application. In the application, I use dagger 2 and architecture components (LiveData, etc.). The test has a function to help me create fake injections for the tested activity. When I use it to mock the ManViewModel it works with no problem and I can run the test. But when I want to set a mock value for the ViewModelProvider.Factory the test throws an error in MainActivity: ViewModelProviders.of(th…iewModelImpl::class.java) must not be null
I have debugged the test and when I'm assigning the mock value it isn't null and in the main activity the values are not null but steel I get the error.
Some help would be appreciated.
The code for MainActivity:
class MainActivity : BaseActivity(), AnimateFactsImage {
#Inject
lateinit var viewModelFactory: ViewModelProvider.Factory
#Inject
lateinit var mainViewModel: MainViewModel
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
binding = DataBindingUtil.setContentView(this, R.layout.activity_main)
mainViewModel = ViewModelProviders.of(this, viewModelFactory).get(MainViewModel::class.java)
// Here is the error: ViewModelProviders.of(th…iewModelImpl::class.java) must not be null
}
}
The code for MainActiviyTest:
#RunWith(AndroidJUnit4::class)
class MainActivityView {
#get:Rule
val activityTestRule = object : ActivityTestRule<MainActivity>(MainActivity::class.java, true, false) {
override fun beforeActivityLaunched() {
super.beforeActivityLaunched()
val myApp = InstrumentationRegistry.getTargetContext().applicationContext as MyApplication
myApp.activityDispatchingAndroidInjector = createFakeActivityInjector<MainActivity> {
mainViewModel = mainView
viewModelFactory = mockMPF // TODO: fix problem, null pointer in activity
}
}
}
private val mockMPF = Mockito.mock(ViewModelProvider.Factory::class.java)
private var mainView = Mockito.mock(MainViewModel::class.java)
private val repoLiveData = MutableLiveData<ApiResponse<Result>>()
#Before
fun setup() {
Mockito.`when`(mainView.getFactsList()).thenReturn(repoLiveData)
}
#Test
fun isListDisplayed() {
repoLiveData.postValue(ApiResponse(Result("title", arrayListOf(Row("title", "des", "img"))), null))
activityTestRule.launchActivity(null)
onView(withId(R.id.recycler_adapter)).check(matches(isDisplayed()))
}
}

How to correctly mock ViewModel on androidTest

I'm currently writing some UI unit tests for a fragment, and one of these #Test is to see if a list of objects is correctly displayed, this is not an integration test, therefore I wish to mock the ViewModel.
The fragment's vars:
class FavoritesFragment : Fragment() {
private lateinit var adapter: FavoritesAdapter
private lateinit var viewModel: FavoritesViewModel
#Inject lateinit var viewModelFactory: FavoritesViewModelFactory
(...)
Here's the code:
#MediumTest
#RunWith(AndroidJUnit4::class)
class FavoritesFragmentTest {
#Rule #JvmField val activityRule = ActivityTestRule(TestFragmentActivity::class.java, true, true)
#Rule #JvmField val instantTaskExecutorRule = InstantTaskExecutorRule()
private val results = MutableLiveData<Resource<List<FavoriteView>>>()
private val viewModel = mock(FavoritesViewModel::class.java)
private lateinit var favoritesFragment: FavoritesFragment
#Before
fun setup() {
favoritesFragment = FavoritesFragment.newInstance()
activityRule.activity.addFragment(favoritesFragment)
`when`(viewModel.getFavourites()).thenReturn(results)
}
(...)
// This is the initial part of the test where I intend to push to the view
#Test
fun whenDataComesInItIsCorrectlyDisplayedOnTheList() {
val resultsList = TestFactoryFavoriteView.generateFavoriteViewList()
results.postValue(Resource.success(resultsList))
(...)
}
I was able to mock the ViewModel but of course, that's not the same ViewModel created inside the Fragment.
So my question really, has someone done this successfully or has some pointers/references that might help me out?
Also, I've tried looking into the google-samples but with no luck.
For reference, the project can be found here: https://github.com/JoaquimLey/transport-eta/

Within your test setup you'll need to provide a test version of the FavoritesViewModelFactory which is being injected in the Fragment.
You could do something like the following, where the Module will need to be added to your TestAppComponent:
#Module
object TestFavoritesViewModelModule {
val viewModelFactory: FavoritesViewModelFactory = mock()
#JvmStatic
#Provides
fun provideFavoritesViewModelFactory(): FavoritesViewModelFactory {
return viewModelFactory
}
}
You'd then be able to provide your Mock viewModel in the test.
fun setupViewModelFactory() {
whenever(TestFavoritesViewModelModule.viewModelFactory.create(FavoritesViewModel::class.java)).thenReturn(viewModel)
}

I have solved this problem using an extra object injected by Dagger, you can find the full example here: https://github.com/fabioCollini/ArchitectureComponentsDemo
In the fragment I am not using directly the ViewModelFactory, I have defined a custom factory defined as a Dagger singleton:
https://github.com/fabioCollini/ArchitectureComponentsDemo/blob/master/uisearch/src/main/java/it/codingjam/github/ui/search/SearchFragment.kt
Then in the test I replace using DaggerMock this custom factory using a factory that always returns a mock instead of the real viewModel:
https://github.com/fabioCollini/ArchitectureComponentsDemo/blob/master/uisearchTest/src/androidTest/java/it/codingjam/github/ui/repo/SearchFragmentTest.kt

Look like, you use kotlin and koin(1.0-beta).
It is my decision for mocking
#RunWith(AndroidJUnit4::class)
class DashboardFragmentTest : KoinTest {
#Rule
#JvmField
val activityRule = ActivityTestRule(SingleFragmentActivity::class.java, true, true)
#Rule
#JvmField
val executorRule = TaskExecutorWithIdlingResourceRule()
#Rule
#JvmField
val countingAppExecutors = CountingAppExecutorsRule()
private val testFragment = DashboardFragment()
private lateinit var dashboardViewModel: DashboardViewModel
private lateinit var router: Router
private val devicesSuccess = MutableLiveData<List<Device>>()
private val devicesFailure = MutableLiveData<String>()
#Before
fun setUp() {
dashboardViewModel = Mockito.mock(DashboardViewModel::class.java)
Mockito.`when`(dashboardViewModel.devicesSuccess).thenReturn(devicesSuccess)
Mockito.`when`(dashboardViewModel.devicesFailure).thenReturn(devicesFailure)
Mockito.`when`(dashboardViewModel.getDevices()).thenAnswer { _ -> Any() }
router = Mockito.mock(Router::class.java)
Mockito.`when`(router.loginActivity(activityRule.activity)).thenAnswer { _ -> Any() }
StandAloneContext.loadKoinModules(hsApp + hsViewModel + api + listOf(module {
single(override = true) { router }
factory(override = true) { dashboardViewModel } bind ViewModel::class
}))
activityRule.activity.setFragment(testFragment)
EspressoTestUtil.disableProgressBarAnimations(activityRule)
}
#After
fun tearDown() {
activityRule.finishActivity()
StandAloneContext.closeKoin()
}
#Test
fun devicesSuccess(){
val list = listOf(Device(deviceName = "name1Item"), Device(deviceName = "name2"), Device(deviceName = "name3"))
devicesSuccess.postValue(list)
onView(withId(R.id.rv_devices)).check(ViewAssertions.matches(ViewMatchers.isCompletelyDisplayed()))
onView(withId(R.id.rv_devices)).check(matches(hasDescendant(withText("name1Item"))))
onView(withId(R.id.rv_devices)).check(matches(hasDescendant(withText("name2"))))
onView(withId(R.id.rv_devices)).check(matches(hasDescendant(withText("name3"))))
}
#Test
fun devicesFailure(){
devicesFailure.postValue("error")
onView(withId(R.id.rv_devices)).check(ViewAssertions.matches(ViewMatchers.isCompletelyDisplayed()))
Mockito.verify(router, times(1)).loginActivity(testFragment.activity!!)
}
#Test
fun devicesCall() {
onView(withId(R.id.rv_devices)).check(ViewAssertions.matches(ViewMatchers.isCompletelyDisplayed()))
Mockito.verify(dashboardViewModel, Mockito.times(1)).getDevices()
}
}

In the example you provided, you are using mockito to return a mock for a specific instance of your view model, and not for every instance.
In order to make this work, you will have to have your fragment use the exact view model mock that you have created.
Most likely this would come from a store or a repository, so you could put your mock there? It really depends on how you setup the acquisition of the view model in your Fragments logic.
Recommendations:
1) Mock the data sources the view model is constructed from or
2) add a fragment.setViewModel() and Mark it as only for use in tests. This is a little ugly, but if you don't want to mock data sources, it is pretty easy this way.

One could easily mock a ViewModel and other objects without Dagger simply by:
Create a wrapper class that can re-route calls to the ViewModelProvider. Below is the production version of the wrapper class that simply passes the calls to the real ViewModelProvider which is passed in as a parameter.
class VMProviderInterceptorImpl : VMProviderInterceptor { override fun get(viewModelProvider: ViewModelProvider, x: Class<out ViewModel>): ViewModel {
return viewModelProvider.get(x)
}
}
Adding getters and setters for this wrapper object to the Application class.
In the Activity rule, before an activity is launched, swap out the real wrapper with a mocked wrapper that does not route the get ViewModel call to the real viewModelProvider and instead provides a mocked object.
I realize this is not as powerful as dagger but the simplicity is attractive.

Testing Android Kotlin app - Mockito with Dagger injects null

I'm learning testing on Android with Mockito and Robolectric. I created very simple app in Kotlin with RxJava and Dagger2, using Clean Architecture. Everything works well on device, but I can't make my test pass. Here is my LoginPresenterTest:
#RunWith(RobolectricGradleTestRunner::class)
#Config(constants = BuildConfig::class)
public class LoginPresenterTest {
private lateinit var loginPresenter: LoginPresenter
#Rule #JvmField
public val mockitoRule: MockitoRule = MockitoJUnit.rule()
#Mock
private lateinit var mockContext: Context
#Mock
private lateinit var mockLoginUseCase: LoginUseCase
#Mock
private lateinit var mockLoginView: LoginView
#Mock
private lateinit var mockCredentialsUseCase: GetCredentials
#Before
public fun setUp() {
loginPresenter = LoginPresenter(mockCredentialsUseCase, mockLoginUseCase)
loginPresenter.view = mockLoginView
}
#Test
public fun testLoginPresenterResume(){
given(mockLoginView.context()).willReturn(mockContext)
loginPresenter.resume();
}
}
LoginPresenter contructor:
class LoginPresenter #Inject constructor(#Named("getCredentials") val getCredentials: UseCase,
#Named("loginUseCase") val loginUseCase: LoginUseCase) : Presenter<LoginView>
in loginPresenter.resume() i have:
override fun resume() {
getCredentials.execute(GetCredentialsSubscriber() as DefaultSubscriber<in Any>)
}
And, finally, GetCredentials:
open class GetCredentials #Inject constructor(var userRepository: UserRepository,
threadExecutor: Executor,
postExecutionThread: PostExecutionThread):
UseCase(threadExecutor, postExecutionThread) {
override fun buildUseCaseObservable(): Observable<Credentials> = userRepository.credentials()
}
The problem is, that every field in GetCredentials is null. I think I miss something (I took pattern from this project: https://github.com/android10/Android-CleanArchitecture), but I can't find what is it. Does anyone know what may cause this?

You're using a mock instance of GetCredentials (#Mock var mockCredentialsUseCase: GetCredentials) that's why you have nulls in its fields. It's rarely a good idea to mock everything apart from the main class under test (LoginPresenter). One way to think of this is to divide the dependencies into peers and internals. I would rewrite the test to something like:
inline fun <reified T:Any> mock() : T = Mockito.mock(T::class.java)
#RunWith(RobolectricGradleTestRunner::class)
#Config(constants = BuildConfig::class)
public class LoginPresenterTest {
val mockContext:Context = mock()
val mockLoginView:LoginView = mock().apply {
given(this.context()).willReturn(mockContext)
}
val userRepository:UserRepository = mock() // or some in memory implementation
val credentials = GetCredentials(userRepository, testThreadExecutor, testPostThreadExecutor) // yes, let's use real GetCredentials implementation
val loginUseCase = LoginUseCase() // and a real LoginUseCase if possible
val loginPresenter = LoginPresenter(credentials, loginUseCase).apply {
view = mockLoginView
}
#Test
public fun testLoginPresenterResume(){
given(mockLoginView.context()).willReturn(mockContext)
loginPresenter.resume();
// do actual assertions as what should happen
}
}
As usual you need to think about what you're testing. The scope of the test does not have to be limited to a single class. It's often easier to think of features you're testing instead of classes (like in BDD). Above all try to avoid tests like this - which in my opinion adds very little value as a regression test but still impedes refactoring.
PS. Roboelectric add helper functions for context