Android 在存储库上使用 Kotlin-Coroutine 进行单元测试以添加/设置喜爱的电影

Question

我正在开发一个使用 themoviedb API 的应用程序。 此应用程序可以查看 The Movie DB 上的所有“正在播放的电影”，您可以将其中一部电影或多部电影保存到内部数据库中作为最喜欢的电影（使用房间）。

我正在使用存储库，现在我正在尝试编写一个单元测试来验证 MovieRepositoryTest 文件上的 setFavoriteMovie 测试用例。

所以这是我在测试 Package MovieRepositoryTest上的代码

import androidx.arch.core.executor.testing.InstantTaskExecutorRule
import androidx.lifecycle.MutableLiveData
import androidx.lifecycle.Observer
import com.dicoding.moviejetpacklast.data.source.MovieRepository
import com.dicoding.moviejetpacklast.data.source.entity.MovieEntity
import com.dicoding.moviejetpacklast.data.source.entity.TvEntity
import com.dicoding.moviejetpacklast.utils.DataDummy
import com.nhaarman.mockitokotlin2.doNothing
import com.nhaarman.mockitokotlin2.times
import com.nhaarman.mockitokotlin2.verify
import junit.framework.Assert.assertEquals
import org.junit.Assert
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::class)
class DetailViewModelTest {
    private val dummyMovie = DataDummy.generateDataMovieDummy()[0]
    private val dummyTvShow = DataDummy.generateDataTvShowDummy()[0]

    private val movieId = dummyMovie.movieId
    private val tvId = dummyTvShow.tvShowId

    private lateinit var viewModel: DetailViewModel

    @get:Rule
    val instantTaskExecutorRule = InstantTaskExecutorRule()

    @Mock
    private lateinit var movieRepository: MovieRepository

    @Mock
    private lateinit var observerMovie: Observer<MovieEntity>

    @Mock
    private lateinit var observerTv: Observer<TvEntity>

    @Before
    fun setUp() {
        viewModel = DetailViewModel(movieRepository)
    }


    @Test
    fun getMovieDetail() {
        val movieDummy = MutableLiveData<MovieEntity>()
        movieDummy.value = dummyMovie

        Mockito.`when`(movieRepository.getMovieDetail(movieId)).thenReturn(movieDummy)

        val movieData = viewModel.getMovieDetail(movieId).value

        Assert.assertNotNull(movieData)
        assertEquals(dummyMovie.id, movieData?.id)
        assertEquals(dummyMovie.movieId, movieData?.movieId)
        assertEquals(dummyMovie.name, movieData?.name)
        assertEquals(dummyMovie.desc, movieData?.desc)
        assertEquals(dummyMovie.poster, movieData?.poster)
        assertEquals(dummyMovie.imgPreview, movieData?.imgPreview)

        viewModel.getMovieDetail(movieId).observeForever(observerMovie)
        verify(observerMovie).onChanged(dummyMovie)
    }

    @Test
    fun getTvDetail() {
        val tvDummy = MutableLiveData<TvEntity>()
        tvDummy.value = dummyTvShow

        Mockito.`when`(movieRepository.getTvDetail(tvId)).thenReturn(tvDummy)

        val tvShowData = viewModel.getTvDetail(tvId).value

        Assert.assertNotNull(tvShowData)
        assertEquals(dummyTvShow.id, tvShowData?.id)
        assertEquals(dummyTvShow.tvShowId, tvShowData?.tvShowId)
        assertEquals(dummyTvShow.name, tvShowData?.name)
        assertEquals(dummyTvShow.desc, tvShowData?.desc)
        assertEquals(dummyTvShow.poster, tvShowData?.poster)
        assertEquals(dummyTvShow.imgPreview, tvShowData?.imgPreview)

        viewModel.getTvDetail(tvId).observeForever(observerTv)
        verify(observerTv).onChanged(dummyTvShow)
    }

    @Test
    fun setFavoriteMovie() {
        viewModel = DetailViewModel(movieRepository)
        doNothing().`when`(movieRepository).setFavoriteMovie(dummyMovie)
        viewModel.setFavoriteMovie(dummyMovie)
        verify(movieRepository, times(1)).setFavoriteMovie(dummyMovie)
    }
}

FakeMovieRepository：（这就像我在主 package 上使用的相同存储库，但我在名为 FakeMovieRepository 的单元测试中再次创建它以帮助在 MovieRepositoryTest 上进行测试）

import androidx.lifecycle.LiveData
import androidx.paging.LivePagedListBuilder
import androidx.paging.PagedList
import com.dicoding.moviejetpacklast.data.source.entity.MovieEntity
import com.dicoding.moviejetpacklast.data.source.entity.TvEntity
import com.dicoding.moviejetpacklast.data.source.remote.RemoteDataSource
import com.dicoding.moviejetpacklast.data.source.response.ApiResponse
import com.dicoding.moviejetpacklast.data.source.response.MovieResponse
import com.dicoding.moviejetpacklast.data.source.response.TvResponse
import com.dicoding.moviejetpacklast.data.source.room.LocalSource
import com.dicoding.moviejetpacklast.data.source.status.Resource
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.launch
import javax.inject.Inject

class FakeMovieRepository @Inject constructor(
    private val remoteDataSource: RemoteDataSource,
    private val localSource: LocalSource
) : MovieDataSource {
    override fun getPopularMovies(): LiveData<Resource<PagedList<MovieEntity>>> {
        return object : NetworkBoundResource<PagedList<MovieEntity>, List<MovieResponse>>() {
            public override fun loadFromDB(): LiveData<PagedList<MovieEntity>> {
                val config = PagedList.Config.Builder().apply {
                    setEnablePlaceholders(false)
                    setInitialLoadSizeHint(4)
                    setPageSize(4)
                }.build()
                return LivePagedListBuilder(localSource.getListMovies(), config).build()
            }

            override fun shouldFetch(data: PagedList<MovieEntity>?): Boolean =
                data == null || data.isEmpty()


            public override fun createCall(): LiveData<ApiResponse<List<MovieResponse>>> =
                remoteDataSource.getPopularMovies()

            public override fun saveCallResult(data: List<MovieResponse>) {
                val movieList = ArrayList<MovieEntity>()
                for (item in data) {
                    val movie = MovieEntity(
                        null,
                        item.id,
                        item.name,
                        item.desc,
                        item.poster,
                        item.imgPreview,
                        false
                    )
                    movieList.add(movie)
                }

                localSource.insertMovies(movieList)
            }

        }.asLiveData()
    }

    override fun getListPopularMovies(): LiveData<PagedList<MovieEntity>> {
        val config = PagedList.Config.Builder().apply {
            setEnablePlaceholders(false)
            setInitialLoadSizeHint(4)
            setPageSize(4)
        }.build()
        return LivePagedListBuilder(localSource.getListFavoriteMovies(), config).build()
    }

    override fun getMovieDetail(movieId: Int): LiveData<MovieEntity> =
        localSource.getDetailMovie(movieId)

    override fun getPopularTv(): LiveData<Resource<PagedList<TvEntity>>> {
        return object : NetworkBoundResource<PagedList<TvEntity>, List<TvResponse>>() {
            public override fun loadFromDB(): LiveData<PagedList<TvEntity>> {
                val config = PagedList.Config.Builder().apply {
                    setEnablePlaceholders(false)
                    setInitialLoadSizeHint(4)
                    setPageSize(4)
                }.build()
                return LivePagedListBuilder(localSource.getListTv(), config).build()
            }

            override fun shouldFetch(data: PagedList<TvEntity>?): Boolean =
                data == null || data.isEmpty()

            public override fun createCall(): LiveData<ApiResponse<List<TvResponse>>> =
                remoteDataSource.getPopularTv()


            public override fun saveCallResult(data: List<TvResponse>) {
                val tvShowList = ArrayList<TvEntity>()
                for (item in data) {
                    val tvShow = TvEntity(
                        null,
                        item.id,
                        item.name,
                        item.desc,
                        item.poster,
                        item.imgPreview,
                        false
                    )
                    tvShowList.add(tvShow)
                }

                localSource.insertTv(tvShowList)
            }

        }.asLiveData()
    }

    override fun getListPopularTv(): LiveData<PagedList<TvEntity>> {
        val config = PagedList.Config.Builder().apply {
            setEnablePlaceholders(false)
            setInitialLoadSizeHint(4)
            setPageSize(4)
        }.build()
        return LivePagedListBuilder(localSource.getListFavoriteTv(), config).build()
    }

    override fun getTvDetail(tvShowId: Int): LiveData<TvEntity> =
        localSource.getDetailTv(tvShowId)

    override fun setFavoriteMovie(movie: MovieEntity) {
        CoroutineScope(Dispatchers.IO).launch {
            localSource.setFavoriteMovie(movie)
        }
    }

    override fun setFavoriteTv(tvShow: TvEntity) {
        CoroutineScope(Dispatchers.IO).launch {
            localSource.setFavoriteTv(tvShow)
        }
    }

}

LiveDataTestUtil：

import androidx.lifecycle.LiveData
import androidx.lifecycle.Observer
import java.util.concurrent.CountDownLatch
import java.util.concurrent.TimeUnit

object LiveDataTestUtil {
    fun <T> getValue(liveData: LiveData<T>): T {
        val data = arrayOfNulls<Any>(1)
        val latch = CountDownLatch(1)

        val observer = object : Observer<T> {
            override fun onChanged(o: T) {
                data[0] = o
                latch.countDown()
                liveData.removeObserver(this)
            }
        }

        liveData.observeForever(observer)

        try {
            latch.await(2, TimeUnit.SECONDS)
        } catch (e: InterruptedException) {
            e.printStackTrace()
        }

        return data[0] as T

    }
}

分页列表直到

import androidx.paging.PagedList
import org.mockito.ArgumentMatchers
import org.mockito.Mockito

object PagedListUtil {

    fun <T> mockPagedList(list: List<T>): PagedList<T> {
        val pagedList = Mockito.mock(PagedList::class.java) as PagedList<T>
        Mockito.`when`(pagedList[ArgumentMatchers.anyInt()]).then { invocation ->
            val index = invocation.arguments.first() as Int
            list[index]
        }
        Mockito.`when`(pagedList.size).thenReturn(list.size)

        return pagedList
    }
}

LocalSource（在主 package 上不在测试包上）

class LocalSource @Inject constructor(private val movieDao: MovieDao) {

    fun getListMovies() : DataSource.Factory<Int, MovieEntity> = movieDao.getListMovies()

    fun getListFavoriteMovies() : DataSource.Factory<Int, MovieEntity> = movieDao.getListFavoriteMovies()

    fun getListTv() : DataSource.Factory<Int, TvEntity> = movieDao.getListTv()

    fun getListFavoriteTv() : DataSource.Factory<Int, TvEntity> = movieDao.getListFavoriteTv()

    fun getDetailMovie(movieId: Int) : LiveData<MovieEntity> = movieDao.getDetailMovieById(movieId)

    fun getDetailTv(tvShowId: Int) : LiveData<TvEntity> = movieDao.getDetailTvById(tvShowId)

    fun insertMovies(movies: List<MovieEntity>) = movieDao.insertMovies(movies)

    fun insertTv(tvShows: List<TvEntity>) = movieDao.insertTv(tvShows)

    fun setFavoriteMovie(movie : MovieEntity) {
        movie.isFavorite = !movie.isFavorite
        movieDao.updateMovie(movie)
    }

    fun setFavoriteTv(tvShow : TvEntity) {
        tvShow.isFavorite = !tvShow.isFavorite
        movieDao.updateTv(tvShow)
    }
}

我在 MovieRepositoryTest 上的 setFavoriteMovie 测试用例上苦苦挣扎，但我总是收到错误消息“需要但未调用，实际上，与此模拟的交互为零。”。 我正在使用 Coroutine 作为调度程序，也许我应该以不同的方式编写代码？

    @Test
    fun setFavoriteMovie() {
        val dataDummy = DataDummy.generateDataMovieDummy()[0].copy(isFavorite = false)
        doNothing().`when`(local).setFavoriteMovie(dataDummy)
        movieRepository.setFavoriteMovie(dataDummy)
        verify(local, times(1)).setFavoriteMovie(dataDummy)
    }

任何帮助，将不胜感激

注意：我的同事说因为我在我测试的代码上使用协程，所以要确保模拟的 object 的实例应该在同一个线程上。 但我不明白