DiscoverViewModelTest.kt

package com.lukasdylan.dicoding.made

import androidx.arch.core.executor.testing.InstantTaskExecutorRule
import com.lukasdylan.dicoding.made.model.Discover
import com.lukasdylan.dicoding.made.model.DiscoverListResponse
import com.lukasdylan.dicoding.made.repository.DiscoverRepositoryImpl
import com.lukasdylan.dicoding.made.service.ApiService
import com.lukasdylan.dicoding.made.utils.ErrorWrapper
import com.lukasdylan.dicoding.made.utils.TestDispatcherProvider
import com.lukasdylan.dicoding.made.viewmodel.DiscoverViewModel
import kotlinx.coroutines.ExperimentalCoroutinesApi
import kotlinx.coroutines.runBlocking
import org.junit.Before
import org.junit.Rule
import org.junit.Test
import org.junit.rules.TestRule
import org.mockito.Mock
import org.mockito.Mockito.`when`
import org.mockito.MockitoAnnotations
import retrofit2.mock.Calls

@ExperimentalCoroutinesApi
class DiscoverViewModelTest {

    @get:Rule
    val rule: TestRule = InstantTaskExecutorRule()

    @Mock
    private lateinit var apiService: ApiService

    private lateinit var discoverViewModel: DiscoverViewModel

    @Before
    fun setup() {
        MockitoAnnotations.initMocks(this)
        val repository = DiscoverRepositoryImpl(apiService)
        discoverViewModel = DiscoverViewModel(repository, TestDispatcherProvider())
    }

    @Test
    internal fun `load Movie list with size 5`() {
        runBlocking {
            val expectedResponse = DiscoverListResponse(
                listOf(
                    Discover(title = "Avengers: Endgame"),
                    Discover(id = 69),
                    Discover(title = ""),
                    Discover(),
                    Discover(voteRating = 8.2)
                )
            )
            val languageParam = MovieConst.LANGUAGE_BAHASA

            `when`(apiService.fetchDiscoverMovieList(BuildConfig.MOVIE_API_KEY, languageParam))
                .thenReturn(Calls.response(expectedResponse))

            discoverViewModel.loadDiscoverByScreenType(MovieConst.MOVIE_TYPE, languageParam)

            testLiveData(discoverViewModel.discoverList) {
                assert(it.isNotNullOrEmpty())
                assert(it?.size.equal(5))
                assert(it?.first()?.title.equals("Avengers: Endgame"))
                assert(it?.get(1)?.id.equal(69))
                assert(it?.get(2)?.name.isNullOrEmpty())
                assert(it?.last()?.voteRating.notEquals(8.5))
            }
        }
    }

    @Test
    internal fun `load TV Show list but return empty data`() {
        runBlocking {
            val expectedResponse = DiscoverListResponse(emptyList())
            val languageParam = MovieConst.LANGUAGE_BAHASA

            `when`(apiService.fetchDiscoverTvShowList(BuildConfig.MOVIE_API_KEY, languageParam))
                .thenReturn(Calls.response(expectedResponse))

            discoverViewModel.loadDiscoverByScreenType(MovieConst.TV_SHOW_TYPE, languageParam)

            testLiveData(discoverViewModel.discoverList) {
                assert(it.isNullOrEmpty())
            }
        }
    }

    @Test
    internal fun `load Movies but got error from Backend`() {
        runBlocking {
            val expectedResponse = Throwable("Kabelnya ketarik")
            val languageParam = MovieConst.LANGUAGE_BAHASA

            `when`(apiService.fetchDiscoverMovieList(BuildConfig.MOVIE_API_KEY, languageParam))
                .thenReturn(Calls.failure(expectedResponse))

            discoverViewModel.loadDiscoverByScreenType(MovieConst.MOVIE_TYPE, languageParam)

            testLiveData(discoverViewModel.discoverList) {
                assert(it.isNullOrEmpty())
            }

            testLiveData(discoverViewModel.errorSnackBarEvent) {
                assert(it.equal(ErrorWrapper(expectedResponse)))
            }
        }
    }
}