Add test to MovieViewModel

buildsystem/dependencies.gradle

@@ -77,9 +77,7 @@ ext {
             androidToolsBuild       : "com.android.tools.build:gradle:${gradle_version}",
             kotlinGradlePlugin      : "org.jetbrains.kotlin:kotlin-gradle-plugin:${kotlin_version}",
             androidAnalyzer         : "com.justpinch:androidanalyzer:${android_analyzer_version}",
-            androidToolsBuild : "com.android.tools.build:gradle:${gradle_version}",
-            kotlinGradlePlugin: "org.jetbrains.kotlin:kotlin-gradle-plugin:${kotlin_version}",
-            safeArgs          : "androidx.navigation:navigation-safe-args-gradle-plugin:${safeargs_version}"
+            safeArgs                : "androidx.navigation:navigation-safe-args-gradle-plugin:${safeargs_version}"
     ]
 
     androidXDependencies = [

presentation/src/main/java/com/architectcoders/presentation/viewmodels/MovieViewModel.kt

@@ -1,6 +1,7 @@
 package com.architectcoders.presentation.viewmodels
 
 import android.util.Log
+import androidx.annotation.VisibleForTesting
 import androidx.lifecycle.LiveData
 import androidx.lifecycle.MutableLiveData
 import com.architectcoders.domain.model.Movie
@@ -65,12 +66,15 @@ class MovieViewModel(
         }
     }
 
-    private fun handleMoviesResponse(movies: List<Movie>) {
+    @VisibleForTesting(otherwise = VisibleForTesting.PRIVATE)
+    fun handleMoviesResponse(movies: List<Movie>) {
         _model.value = UiModel.Content(movies)
     }
 
-    private fun handleErrorResponse(throwable: Throwable) {
+    @VisibleForTesting(otherwise = VisibleForTesting.PRIVATE)
+    fun handleErrorResponse(throwable: Throwable) {
         Log.d("Throwable", "asasd")
         //TODO
     }
+
 }

presentation/src/test/java/com/architectcoders/presentation/viewmodels/MovieViewModelTest.kt

@@ -0,0 +1,116 @@
+package com.architectcoders.presentation.viewmodels
+
+import androidx.arch.core.executor.testing.InstantTaskExecutorRule
+import androidx.lifecycle.Observer
+import com.gabriel.usecases.GetFavoriteMoviesUseCase
+import com.gabriel.usecases.GetPopularMoviesUseCase
+import com.gabriel.usecases.GetSearchMoviesUseCase
+import com.gabriel.usecases.GetTopRatedMoviesUseCase
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.runBlocking
+import org.junit.Before
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.mockito.Mock
+import org.mockito.Mockito.*
+import org.mockito.junit.MockitoJUnitRunner
+
+@RunWith(MockitoJUnitRunner.Silent::class)
+class MovieViewModelTest {
+
+    @get:Rule
+    val rule = InstantTaskExecutorRule()
+
+    @Mock
+    lateinit var getPopularMoviesUseCase: GetPopularMoviesUseCase
+
+    @Mock
+    lateinit var getTopRatedMoviesUseCase: GetTopRatedMoviesUseCase
+
+    @Mock
+    lateinit var getSearchMovieListUseCase: GetSearchMoviesUseCase
+
+    @Mock
+    lateinit var getFavoriteMoviesUseCase: GetFavoriteMoviesUseCase
+
+    @Mock
+    lateinit var observer: Observer<MovieViewModel.UiModel>
+
+    private lateinit var viewModel: MovieViewModel
+
+    @ExperimentalCoroutinesApi
+    @Before
+    fun setUp() {
+        viewModel = MovieViewModel(
+            getPopularMoviesUseCase,
+            getTopRatedMoviesUseCase,
+            getSearchMovieListUseCase,
+            getFavoriteMoviesUseCase,
+            Dispatchers.Unconfined
+        )
+    }
+
+    @Test
+    fun `after Initialise it request movies`() = runBlocking {
+        viewModel.model.observeForever(observer)
+        verify(observer, times(1)).onChanged(MovieViewModel.UiModel.RequestMovies)
+    }
+
+    @Test
+    fun onRequestPopularMovies() = runBlocking {
+        viewModel.model.observeForever(observer)
+
+        `when`(viewModel.onRequestPopularMovies()).thenCallRealMethod()
+        verify(observer, times(1)).onChanged(MovieViewModel.UiModel.Loading)
+        verify(getPopularMoviesUseCase, times(0)).execute({
+            viewModel.handleMoviesResponse(it)
+        },{
+            viewModel.handleErrorResponse(it)
+        })
+    }
+
+    @Test
+    fun onRequestTopRatedMovies() = runBlocking {
+        viewModel.model.observeForever(observer)
+
+        `when`(viewModel.onRequestTopRatedMovies()).thenCallRealMethod()
+        verify(observer, times(1)).onChanged(MovieViewModel.UiModel.Loading)
+        verify(getTopRatedMoviesUseCase, times(0)).execute({
+            viewModel.handleMoviesResponse(it)
+        },{
+            viewModel.handleErrorResponse(it)
+        })
+    }
+
+    @Test
+    fun onRequestFavoriteMovies() = runBlocking {
+        viewModel.model.observeForever(observer)
+
+        `when`(viewModel.onRequestFavoriteMovies()).thenCallRealMethod()
+        verify(observer, times(1)).onChanged(MovieViewModel.UiModel.Loading)
+        verify(getPopularMoviesUseCase, times(0)).execute({
+            viewModel.handleMoviesResponse(it)
+        },{
+            viewModel.handleErrorResponse(it)
+        })
+    }
+
+    @Test
+    fun onSearchMovies() = runBlocking {
+        viewModel.model.observeForever(observer)
+
+        val query = "001"
+        `when`(viewModel.onSearchMovies(query)).thenCallRealMethod()
+        verify(observer, times(1)).onChanged(MovieViewModel.UiModel.Loading)
+        verify(getSearchMovieListUseCase, times(0)).execute({
+            viewModel.handleMoviesResponse(it)
+        },{
+            viewModel.handleErrorResponse(it)
+        },
+            query
+        )
+    }
+
+}