#68. First test added. Many things have to be reviewed after accept t…

buildsystem/dependencies.gradle

@@ -25,7 +25,7 @@ ext {
 
     // Test
     junit_version = '4.13'
-    mockito_version = '3.3.1'
+    mockito_kotlin_version = '2.1.0'
     mockitoinline_version = '3.3.0'
 
     // Android Core Testing
@@ -74,9 +74,9 @@ ext {
     ]
 
     classpathDependencies = [
-            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}",
+            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}"
@@ -90,24 +90,24 @@ ext {
     ]
 
     testDependencies = [
-            jUnit           : "junit:junit:${junit_version}",
-            mockitoCore     : "org.mockito:mockito-core:${mockito_version}",
-            mokitoInlline   : "org.mockito:mockito-inline:${mockitoinline_version}",
+            jUnit        : "junit:junit:${junit_version}",
+            mockitoKotlin: "com.nhaarman.mockitokotlin2:mockito-kotlin:${mockito_kotlin_version}",
+            mokitoInlline: "org.mockito:mockito-inline:${mockitoinline_version}",
     ]
 
     androidXTestLibs = [
-            androidCoreTesting : "androidx.arch.core:core-testing:${archcoretesting_version}"
+            androidCoreTesting: "androidx.arch.core:core-testing:${archcoretesting_version}"
     ]
 
     androidTestDependencies = [
             androidXJUnit: "androidx.test.ext:junit:${androidx_junit_version}",
-            testRunner: "androidx.test:runner:${testrunner_version}",
-            testRules:  "androidx.test:rules:${testrules_version}",
+            testRunner   : "androidx.test:runner:${testrunner_version}",
+            testRules    : "androidx.test:rules:${testrules_version}",
             espressoCore : "androidx.test.espresso:espresso-core:${espresso_core_version}",
     ]
 
     androidDependenciesFramework = [
-            dagger: "com.google.dagger:dagger:${daggerVersion}",
+            dagger          : "com.google.dagger:dagger:${daggerVersion}",
             servicesLocation: "com.google.android.gms:play-services-location:${servicesLocationVersion}"
 
     ]
@@ -157,6 +157,6 @@ ext {
     ]
 
     dexterDependencies = [
-            dexter : "com.karumi:dexter:${dexterVersion}"
+            dexter: "com.karumi:dexter:${dexterVersion}"
     ]
 }

presentation/build.gradle

@@ -36,6 +36,7 @@ dependencies {
     implementation project(':domain')
     implementation project(':usecases')
     implementation project(':generic')
+    implementation project(":testShared")
     implementation fileTree(dir: 'libs', include: ['*.jar'])
     implementation jetBrainsDependencies.values()
     implementation androidXDependencies.values()

presentation/src/main/java/com/architectcoders/presentation/event/Event.kt

@@ -0,0 +1,18 @@
+package com.architectcoders.presentation.event
+
+open class Event<out T>(private val content: T) {
+
+    var hasBeenHandled = false
+        private set
+
+    fun getContentIfNotHandled(): T? {
+        return if (hasBeenHandled) {
+            null
+        } else {
+            hasBeenHandled = true
+            content
+        }
+    }
+
+    fun peekContent(): T = content
+}

presentation/src/main/java/com/architectcoders/presentation/event/EventObserver.kt

@@ -0,0 +1,11 @@
+package com.architectcoders.presentation.event
+
+import androidx.lifecycle.Observer
+
+class EventObserver<T>(private val onEventUnhandledContent: (T) -> Unit) : Observer<Event<T>> {
+    override fun onChanged(event: Event<T>?) {
+        event?.getContentIfNotHandled()?.let { value ->
+            onEventUnhandledContent(value)
+        }
+    }
+}

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

@@ -0,0 +1,74 @@
+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 org.junit.Before
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.mockito.Mock
+import org.mockito.Mockito.verify
+import org.mockito.junit.MockitoJUnitRunner
+
+@RunWith(MockitoJUnitRunner::class)
+class MovieViewModelTest {
+
+    @get:Rule
+    val rule = InstantTaskExecutorRule()
+
+    @Mock
+    lateinit var getPopularMoviesUseCase: GetPopularMoviesUseCase
+
+    @Mock
+    lateinit var getTopRatedMoviesUseCase: GetTopRatedMoviesUseCase
+
+    @Mock
+    lateinit var getSearchMoviesUseCase: GetSearchMoviesUseCase
+
+    @Mock
+    lateinit var getFavoriteMoviesUseCase: GetFavoriteMoviesUseCase
+
+    @Mock
+    lateinit var observer: Observer<MovieViewModel.UiModel>
+
+    private lateinit var vm: MovieViewModel
+
+    @Before
+    fun setUp() {
+        vm = MovieViewModel(
+            getPopularMoviesUseCase,
+            getTopRatedMoviesUseCase,
+            getSearchMoviesUseCase,
+            getFavoriteMoviesUseCase,
+            Dispatchers.Unconfined
+        )
+    }
+
+    @Test
+    fun `Observing LiveData launches request movies`() {
+        vm.model.observeForever(observer)
+
+        verify(observer).onChanged(MovieViewModel.UiModel.RequestMovies)
+    }
+
+//    @Test
+//    fun `After requesting the permission, loading is shown`() {
+//        runBlocking {
+//            val movies = listOf(mockedMovie.copy(id = 1))
+//            whenever(getPopularMoviesUseCase.useCaseExecution(null)).thenReturn(
+//                DataState.Success(
+//                    movies
+//                )
+//            )
+//
+//            vm.onRequestPopularMovies()
+//
+//            verify(observer).onChanged(MovieViewModel.UiModel.Content(movies))
+//        }
+//    }
+}

settings.gradle

@@ -1,2 +1,3 @@
 include ':app', ':presentation', ':domain', ':data', ':generic', ':usecases'
 rootProject.name='equipocinco'
+include ':testShared'

testShared/.gitignore

@@ -0,0 +1 @@
+/build

testShared/build.gradle

@@ -0,0 +1,9 @@
+apply plugin: 'java-library'
+apply plugin: 'kotlin'
+
+dependencies {
+    implementation project(":domain")
+
+    implementation jetBrainsDependencies.values()
+    implementation coroutinesDependencies.values()
+}

testShared/src/main/java/com/architectcoders/testshared/Mocks.kt

@@ -0,0 +1,17 @@
+package com.architectcoders.testshared
+
+import com.architectcoders.domain.model.Movie
+
+val mockedMovie = Movie(
+    0,
+    "Title",
+    "Overview",
+    "01/01/2025",
+    "",
+    "",
+    "EN",
+    "Title",
+    5.0,
+    5.1,
+    false
+)

usecases/src/main/java/com/gabriel/usecases/GetPopularMoviesUseCase.kt

@@ -7,7 +7,7 @@ import com.architectcoders.domain.state.DataState
 class GetPopularMoviesUseCase(private val moviesRepository: MoviesRepository) :
     MoviesBaseUseCase<List<Movie>, Any>() {
 
-    override suspend fun useCaseExecution(params: Any?): DataState<List<Movie>> {
+    public override suspend fun useCaseExecution(params: Any?): DataState<List<Movie>> {
         return moviesRepository.getPopularMovies()
     }
 }