kiwix/kiwix-android
1
0
Fork 0
mirror of https://github.com/kiwix/kiwix-android.git synced 2025-09-17 19:35:36 -04:00
Code Issues Packages Projects Releases Wiki Activity

Improved the display of the "Downloading online library progress" message — previously, it was sometimes not shown, and only the progress bar at the top was visible.

Browse Source 
* Updated the logic to hide the top progress bar when updating the library items while applying filters.
* Refactored all unit test cases to properly support coroutines.
This commit is contained in:
MohitMaliFtechiz 2025-05-22 23:55:13 +05:30
parent 989b22f563
commit e7b1c94f3b
3 changed files with 261 additions and 232 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

108
app/src/main/java/org/kiwix/kiwixmobile/nav/destination/library/online/OnlineLibraryFragment.kt
View File

@ -145,7 +145,7 @@ class OnlineLibraryFragment : BaseFragment(), FragmentActivityExtensions {
private fun onSearchClear() { private fun onSearchClear() {
onlineLibraryScreenState.value.update { onlineLibraryScreenState.value.update {
copy(searchText = "", scanningProgressItem = false to "", isRefreshing = true) copy(searchText = "")
} }
zimManageViewModel.onlineBooksSearchedQuery.value = null zimManageViewModel.onlineBooksSearchedQuery.value = null
zimManageViewModel.requestFiltering.tryEmit("") zimManageViewModel.requestFiltering.tryEmit("")
@ -159,7 +159,7 @@ class OnlineLibraryFragment : BaseFragment(), FragmentActivityExtensions {
zimManageViewModel.onlineBooksSearchedQuery.value = searchText zimManageViewModel.onlineBooksSearchedQuery.value = searchText
} }
onlineLibraryScreenState.value.update { onlineLibraryScreenState.value.update {
copy(searchText = searchText, scanningProgressItem = false to "", isRefreshing = true) copy(searchText = searchText)
} }
zimManageViewModel.requestFiltering.tryEmit(searchText) zimManageViewModel.requestFiltering.tryEmit(searchText)
} }
@ -248,31 +248,51 @@ class OnlineLibraryFragment : BaseFragment(), FragmentActivityExtensions {
) )
DialogHost(alertDialogShower) DialogHost(alertDialogShower)
} }
zimManageViewModel.libraryItems observeViewModelData()
.onEach { onLibraryItemsChange(it) }
.launchIn(viewLifecycleOwner.lifecycleScope)
.also {
coreMainActivity.navHostContainer
.setBottomMarginToFragmentContainerView(0)
}
zimManageViewModel.libraryListIsRefreshing.observe(
viewLifecycleOwner,
Observer { onRefreshStateChange(it, true) }
)
zimManageViewModel.networkStates.observe(viewLifecycleOwner, Observer(::onNetworkStateChange))
zimManageViewModel.shouldShowWifiOnlyDialog.observe(
viewLifecycleOwner
) {
if (it && !NetworkUtils.isWiFi(requireContext())) {
showInternetAccessViaMobileNetworkDialog()
hideProgressBarOfFetchingOnlineLibrary()
}
}
zimManageViewModel.downloadProgress.observe(viewLifecycleOwner, ::onLibraryStatusChanged)
showPreviouslySearchedTextInSearchView() showPreviouslySearchedTextInSearchView()
startDownloadingLibrary() startDownloadingLibrary()
} }
private fun observeViewModelData() {
zimManageViewModel.apply {
// Observe when library items changes.
libraryItems
.onEach { onLibraryItemsChange(it) }
.launchIn(viewLifecycleOwner.lifecycleScope)
.also {
coreMainActivity.navHostContainer
.setBottomMarginToFragmentContainerView(0)
}
// Observe when online library downloading.
onlineLibraryDownloading
.onEach {
if (it) {
showProgressBarOfFetchingOnlineLibrary()
} else {
hideProgressBarOfFetchingOnlineLibrary()
}
}.launchIn(viewLifecycleOwner.lifecycleScope)
// Observe when library list refreshing e.g. applying filters.
libraryListIsRefreshing.observe(
viewLifecycleOwner,
Observer { onRefreshStateChange(it) }
)
// Observe network changes.
networkStates.observe(viewLifecycleOwner, Observer(::onNetworkStateChange))
// Observe `shouldShowWifiOnlyDialog` should show.
shouldShowWifiOnlyDialog.observe(
viewLifecycleOwner
) {
if (it && !NetworkUtils.isWiFi(requireContext())) {
showInternetAccessViaMobileNetworkDialog()
hideProgressBarOfFetchingOnlineLibrary()
}
}
// Observe the download progress.
downloadProgress.observe(viewLifecycleOwner, ::onLibraryStatusChanged)
}
}
private fun showPreviouslySearchedTextInSearchView() { private fun showPreviouslySearchedTextInSearchView() {
zimManageViewModel.onlineBooksSearchedQuery.value.takeIf { it?.isNotEmpty() == true } zimManageViewModel.onlineBooksSearchedQuery.value.takeIf { it?.isNotEmpty() == true }
?.let { ?.let {
@ -365,18 +385,15 @@ class OnlineLibraryFragment : BaseFragment(), FragmentActivityExtensions {
onlineLibraryScreenState.value.update { onlineLibraryScreenState.value.update {
copy(noContentViewItem = "" to false) copy(noContentViewItem = "" to false)
} }
showProgressBarOfFetchingOnlineLibrary()
} }
private fun hideRecyclerviewAndShowSwipeDownForLibraryErrorText() { private fun hideRecyclerviewAndShowSwipeDownForLibraryErrorText() {
onlineLibraryScreenState.value.update { onlineLibraryScreenState.value.update {
copy(noContentViewItem = getString(string.swipe_down_for_library) to true) copy(noContentViewItem = getString(string.swipe_down_for_library) to true)
} }
hideProgressBarOfFetchingOnlineLibrary()
} }
private fun showProgressBarOfFetchingOnlineLibrary() { private fun showProgressBarOfFetchingOnlineLibrary() {
onRefreshStateChange(isRefreshing = false, shouldShowScanningProgressItem = false)
onlineLibraryScreenState.value.update { onlineLibraryScreenState.value.update {
copy( copy(
noContentViewItem = "" to false, noContentViewItem = "" to false,
@ -387,7 +404,6 @@ class OnlineLibraryFragment : BaseFragment(), FragmentActivityExtensions {
} }
private fun hideProgressBarOfFetchingOnlineLibrary() { private fun hideProgressBarOfFetchingOnlineLibrary() {
onRefreshStateChange(isRefreshing = false, false)
onlineLibraryScreenState.value.update { onlineLibraryScreenState.value.update {
copy( copy(
isRefreshing = false, isRefreshing = false,
@ -428,35 +444,29 @@ class OnlineLibraryFragment : BaseFragment(), FragmentActivityExtensions {
onSearchClear() onSearchClear()
} }
private fun onRefreshStateChange( private fun onRefreshStateChange(isRefreshing: Boolean?) {
isRefreshing: Boolean?, val refreshing = isRefreshing == true
shouldShowScanningProgressItem: Boolean
) {
var refreshing = isRefreshing == true
val onlineLibraryState = onlineLibraryScreenState.value.value
// do not show the refreshing when the online library is downloading
if (onlineLibraryState.scanningProgressItem.first ||
onlineLibraryState.noContentViewItem.second
) {
refreshing = false
}
onlineLibraryScreenState.value.update { onlineLibraryScreenState.value.update {
copy( copy(isRefreshing = refreshing)
isRefreshing = refreshing,
scanningProgressItem = shouldShowScanningProgressItem to onlineLibraryState.scanningProgressItem.second
)
} }
} }
private fun onNetworkStateChange(networkState: NetworkState?) { private fun onNetworkStateChange(networkState: NetworkState?) {
when (networkState) { when (networkState) {
NetworkState.CONNECTED -> { NetworkState.CONNECTED -> {
if (NetworkUtils.isWiFi(requireContext())) { when {
refreshFragment(false) NetworkUtils.isWiFi(requireContext()) -> {
} else if (noWifiWithWifiOnlyPreferenceSet) { if (!zimManageViewModel.isOnlineLibraryDownloading) {
hideRecyclerviewAndShowSwipeDownForLibraryErrorText() refreshFragment(false)
} else if (!noWifiWithWifiOnlyPreferenceSet) { }
if (onlineLibraryScreenState.value.value.onlineLibraryList?.isEmpty() == true) { }
noWifiWithWifiOnlyPreferenceSet -> {
hideRecyclerviewAndShowSwipeDownForLibraryErrorText()
}
onlineLibraryScreenState.value.value.onlineLibraryList.isNullOrEmpty() &&
!zimManageViewModel.isOnlineLibraryDownloading -> {
startDownloadingLibrary(true) startDownloadingLibrary(true)
showProgressBarOfFetchingOnlineLibrary() showProgressBarOfFetchingOnlineLibrary()
} }

38
app/src/main/java/org/kiwix/kiwixmobile/zimManager/ZimManageViewModel.kt
View File

@ -33,6 +33,8 @@ import kotlinx.coroutines.channels.BufferOverflow
import kotlinx.coroutines.flow.Flow import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.MutableSharedFlow import kotlinx.coroutines.flow.MutableSharedFlow
import kotlinx.coroutines.flow.MutableStateFlow import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.flow.asStateFlow
import kotlinx.coroutines.flow.catch import kotlinx.coroutines.flow.catch
import kotlinx.coroutines.flow.combine import kotlinx.coroutines.flow.combine
import kotlinx.coroutines.flow.debounce import kotlinx.coroutines.flow.debounce
@ -159,13 +161,15 @@ class ZimManageViewModel @Inject constructor(
private var isUnitTestCase: Boolean = false private var isUnitTestCase: Boolean = false
val sideEffects: MutableSharedFlow<SideEffect<*>> = MutableSharedFlow() val sideEffects: MutableSharedFlow<SideEffect<*>> = MutableSharedFlow()
val libraryItems = MutableStateFlow<List<LibraryListItem>>(emptyList()) private val _libraryItems = MutableStateFlow<List<LibraryListItem>>(emptyList())
val libraryItems: StateFlow<List<LibraryListItem>> = _libraryItems.asStateFlow()
val fileSelectListStates: MutableLiveData<FileSelectListState> = MutableLiveData() val fileSelectListStates: MutableLiveData<FileSelectListState> = MutableLiveData()
val deviceListScanningProgress = MutableLiveData<Int>() val deviceListScanningProgress = MutableLiveData<Int>()
val libraryListIsRefreshing = MutableLiveData<Boolean>() val libraryListIsRefreshing = MutableLiveData<Boolean>()
val onlineLibraryDownloading = MutableStateFlow(false)
val shouldShowWifiOnlyDialog = MutableLiveData<Boolean>() val shouldShowWifiOnlyDialog = MutableLiveData<Boolean>()
val networkStates = MutableLiveData<NetworkState>() val networkStates = MutableLiveData<NetworkState>()
val networkLibrary = MutableSharedFlow<LibraryNetworkEntity>(replay = 0)
val requestFileSystemCheck = MutableSharedFlow<Unit>(replay = 0) val requestFileSystemCheck = MutableSharedFlow<Unit>(replay = 0)
val fileSelectActions = MutableSharedFlow<FileSelectActions>() val fileSelectActions = MutableSharedFlow<FileSelectActions>()
private val requestDownloadLibrary = MutableSharedFlow<Unit>( private val requestDownloadLibrary = MutableSharedFlow<Unit>(
@ -173,7 +177,9 @@ class ZimManageViewModel @Inject constructor(
extraBufferCapacity = 1, extraBufferCapacity = 1,
onBufferOverflow = BufferOverflow.DROP_OLDEST onBufferOverflow = BufferOverflow.DROP_OLDEST
) )
private var isOnlineLibraryDownloading = false
@Volatile
var isOnlineLibraryDownloading = false
val requestFiltering = MutableStateFlow("") val requestFiltering = MutableStateFlow("")
val onlineBooksSearchedQuery = MutableLiveData<String>() val onlineBooksSearchedQuery = MutableLiveData<String>()
private val coroutineJobs: MutableList<Job> = mutableListOf() private val coroutineJobs: MutableList<Job> = mutableListOf()
@ -187,14 +193,10 @@ class ZimManageViewModel @Inject constructor(
} }
fun requestOnlineLibraryIfNeeded(isExplicitRefresh: Boolean) { fun requestOnlineLibraryIfNeeded(isExplicitRefresh: Boolean) {
val libraryItems = libraryItems.value if (isOnlineLibraryDownloading && !isExplicitRefresh) return
val shouldDownloadOnlineLibrary = isOnlineLibraryDownloading = true
isExplicitRefresh || (!isOnlineLibraryDownloading && libraryItems.isEmpty()) viewModelScope.launch {
if (shouldDownloadOnlineLibrary) { requestDownloadLibrary.tryEmit(Unit)
viewModelScope.launch {
requestDownloadLibrary.emit(Unit)
isOnlineLibraryDownloading = true
}
} }
} }
@ -282,7 +284,6 @@ class ZimManageViewModel @Inject constructor(
private fun observeCoroutineFlows(dispatcher: CoroutineDispatcher = Dispatchers.IO) { private fun observeCoroutineFlows(dispatcher: CoroutineDispatcher = Dispatchers.IO) {
val downloads = downloadDao.downloads() val downloads = downloadDao.downloads()
val booksFromDao = books() val booksFromDao = books()
val networkLibrary = MutableSharedFlow<LibraryNetworkEntity>(replay = 0)
val languages = languageDao.languages() val languages = languageDao.languages()
coroutineJobs.apply { coroutineJobs.apply {
add(scanBooksFromStorage(dispatcher)) add(scanBooksFromStorage(dispatcher))
@ -399,7 +400,9 @@ class ZimManageViewModel @Inject constructor(
.flatMapConcat { .flatMapConcat {
shouldProceedWithDownload() shouldProceedWithDownload()
.flatMapConcat { kiwixService -> .flatMapConcat { kiwixService ->
downloadLibraryFlow(kiwixService) downloadLibraryFlow(kiwixService).also {
onlineLibraryDownloading.tryEmit(true)
}
} }
} }
} }
@ -407,11 +410,15 @@ class ZimManageViewModel @Inject constructor(
.catch { .catch {
it.printStackTrace().also { it.printStackTrace().also {
isOnlineLibraryDownloading = false isOnlineLibraryDownloading = false
onlineLibraryDownloading.tryEmit(false)
} }
} }
.onEach { .onEach {
library.emit(it).also { library.emit(it).also {
isOnlineLibraryDownloading = false // Setting this to true because once library downloaded we don't need to download again
// until user wants to refresh the online library.
isOnlineLibraryDownloading = true
onlineLibraryDownloading.tryEmit(false)
} }
} }
.flowOn(dispatcher) .flowOn(dispatcher)
@ -495,10 +502,11 @@ class ZimManageViewModel @Inject constructor(
} }
.onEach { libraryListIsRefreshing.postValue(false) } .onEach { libraryListIsRefreshing.postValue(false) }
.catch { throwable -> .catch { throwable ->
libraryListIsRefreshing.postValue(false)
throwable.printStackTrace() throwable.printStackTrace()
Log.e("ZimManageViewModel", "Error----$throwable") Log.e("ZimManageViewModel", "Error----$throwable")
} }
.collect { libraryItems.emit(it) } .collect { _libraryItems.emit(it) }
} }
private fun updateLanguagesInDao( private fun updateLanguagesInDao(

347
app/src/test/java/org/kiwix/kiwixmobile/zimManager/ZimManageViewModelTest.kt
View File

@ -23,29 +23,32 @@ import android.net.ConnectivityManager
import android.net.NetworkCapabilities import android.net.NetworkCapabilities
import android.net.NetworkCapabilities.TRANSPORT_WIFI import android.net.NetworkCapabilities.TRANSPORT_WIFI
import android.os.Build import android.os.Build
import androidx.lifecycle.asFlow
import app.cash.turbine.TurbineTestContext import app.cash.turbine.TurbineTestContext
import app.cash.turbine.test import app.cash.turbine.test
import com.jraska.livedata.test import com.jraska.livedata.test
import io.mockk.clearAllMocks import io.mockk.clearAllMocks
import io.mockk.coEvery import io.mockk.coEvery
import io.mockk.coVerify
import io.mockk.every import io.mockk.every
import io.mockk.mockk import io.mockk.mockk
import io.mockk.verify import io.mockk.verify
import io.reactivex.processors.PublishProcessor import io.reactivex.processors.PublishProcessor
import io.reactivex.schedulers.TestScheduler import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.ExperimentalCoroutinesApi import kotlinx.coroutines.ExperimentalCoroutinesApi
import kotlinx.coroutines.delay
import kotlinx.coroutines.flow.Flow import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.MutableStateFlow import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.launch import kotlinx.coroutines.launch
import kotlinx.coroutines.runBlocking import kotlinx.coroutines.runBlocking
import kotlinx.coroutines.test.StandardTestDispatcher
import kotlinx.coroutines.test.TestScope import kotlinx.coroutines.test.TestScope
import kotlinx.coroutines.test.advanceUntilIdle import kotlinx.coroutines.test.advanceUntilIdle
import kotlinx.coroutines.test.resetMain
import kotlinx.coroutines.test.runTest import kotlinx.coroutines.test.runTest
import kotlinx.coroutines.test.setMain
import org.assertj.core.api.Assertions.assertThat import org.assertj.core.api.Assertions.assertThat
import org.junit.jupiter.api.AfterAll import org.junit.jupiter.api.AfterAll
import org.junit.jupiter.api.BeforeEach import org.junit.jupiter.api.BeforeEach
import org.junit.jupiter.api.Disabled
import org.junit.jupiter.api.Nested import org.junit.jupiter.api.Nested
import org.junit.jupiter.api.Test import org.junit.jupiter.api.Test
import org.junit.jupiter.api.extension.ExtendWith import org.junit.jupiter.api.extension.ExtendWith
@ -92,11 +95,9 @@ import org.kiwix.sharedFunctions.bookOnDisk
import org.kiwix.sharedFunctions.downloadModel import org.kiwix.sharedFunctions.downloadModel
import org.kiwix.sharedFunctions.language import org.kiwix.sharedFunctions.language
import org.kiwix.sharedFunctions.libraryNetworkEntity import org.kiwix.sharedFunctions.libraryNetworkEntity
import org.kiwix.sharedFunctions.resetSchedulers
import org.kiwix.sharedFunctions.setScheduler
import java.util.Locale import java.util.Locale
import java.util.concurrent.TimeUnit.MILLISECONDS
@OptIn(ExperimentalCoroutinesApi::class)
@ExtendWith(InstantExecutorExtension::class) @ExtendWith(InstantExecutorExtension::class)
class ZimManageViewModelTest { class ZimManageViewModelTest {
private val downloadRoomDao: DownloadRoomDao = mockk() private val downloadRoomDao: DownloadRoomDao = mockk()
@ -126,24 +127,20 @@ class ZimManageViewModelTest {
MutableStateFlow<FileSystemState>(FileSystemState.DetectingFileSystem) MutableStateFlow<FileSystemState>(FileSystemState.DetectingFileSystem)
private val networkStates: PublishProcessor<NetworkState> = PublishProcessor.create() private val networkStates: PublishProcessor<NetworkState> = PublishProcessor.create()
private val booksOnDiskListItems = MutableStateFlow<List<BooksOnDiskListItem>>(emptyList()) private val booksOnDiskListItems = MutableStateFlow<List<BooksOnDiskListItem>>(emptyList())
private val testDispatcher = StandardTestDispatcher()
private val testScheduler = TestScheduler()
init {
setScheduler(testScheduler)
}
@OptIn(ExperimentalCoroutinesApi::class)
@AfterAll @AfterAll
fun teardown() { fun teardown() {
Dispatchers.resetMain()
viewModel.onClearedExposed() viewModel.onClearedExposed()
resetSchedulers()
} }
@Suppress("DEPRECATION")
@BeforeEach @BeforeEach
fun init() { fun init() {
Dispatchers.setMain(testDispatcher)
clearAllMocks() clearAllMocks()
every { defaultLanguageProvider.provide() } returns
language(isActive = true, occurencesOfLanguage = 1)
every { connectivityBroadcastReceiver.action } returns "test" every { connectivityBroadcastReceiver.action } returns "test"
every { downloadRoomDao.downloads() } returns downloads every { downloadRoomDao.downloads() } returns downloads
every { newBookDao.books() } returns books every { newBookDao.books() } returns books
@ -166,6 +163,13 @@ class ZimManageViewModelTest {
connectivityManager.getNetworkCapabilities(connectivityManager.activeNetwork) connectivityManager.getNetworkCapabilities(connectivityManager.activeNetwork)
} returns networkCapabilities } returns networkCapabilities
every { networkCapabilities.hasTransport(TRANSPORT_WIFI) } returns true every { networkCapabilities.hasTransport(TRANSPORT_WIFI) } returns true
every { sharedPreferenceUtil.prefWifiOnly } returns true
downloads.value = emptyList()
booksOnFileSystem.value = emptyList()
books.value = emptyList()
languages.value = emptyList()
fileSystemStates.value = FileSystemState.DetectingFileSystem
booksOnDiskListItems.value = emptyList()
viewModel = viewModel =
ZimManageViewModel( ZimManageViewModel(
downloadRoomDao, downloadRoomDao,
@ -185,7 +189,8 @@ class ZimManageViewModelTest {
setIsUnitTestCase() setIsUnitTestCase()
setAlertDialogShower(alertDialogShower) setAlertDialogShower(alertDialogShower)
} }
testScheduler.triggerActions() viewModel.fileSelectListStates.value = FileSelectListState(emptyList())
runBlocking { viewModel.networkLibrary.emit(libraryNetworkEntity()) }
} }
@Nested @Nested
@ -216,45 +221,38 @@ class ZimManageViewModelTest {
@Nested @Nested
inner class Books { inner class Books {
@OptIn(ExperimentalCoroutinesApi::class)
@Test @Test
fun `emissions from data source are observed`() = runTest { fun `emissions from data source are observed`() = runTest {
val expectedList = listOf(bookOnDisk()) val expectedList = listOf(bookOnDisk())
booksOnDiskListItems.value = expectedList testFlow(
runBlocking { viewModel.fileSelectListStates.asFlow(),
// adding delay because we are converting this in flow. triggerAction = { booksOnDiskListItems.emit(expectedList) },
delay(3000) assert = {
} skipItems(1)
viewModel.fileSelectListStates.test() assertThat(awaitItem()).isEqualTo(FileSelectListState(expectedList))
.assertValue(FileSelectListState(expectedList)) }
)
} }
@OptIn(ExperimentalCoroutinesApi::class)
@Test @Test
@Disabled( fun `books found on filesystem are filtered by books already in db`() = runTest {
"this is flaky due to converting the `rxJava` to flow in ZimManageViewModel.\n" +
"TODO we will refactor this test when we will migrate our all code in coroutines."
)
fun `books found on filesystem are filtered by books already in db`() {
every { application.getString(any()) } returns "" every { application.getString(any()) } returns ""
val expectedBook = bookOnDisk(1L, book("1")) val expectedBook = bookOnDisk(1L, book("1"))
val bookToRemove = bookOnDisk(1L, book("2")) val bookToRemove = bookOnDisk(1L, book("2"))
testScheduler.triggerActions() advanceUntilIdle()
runBlocking { viewModel.requestFileSystemCheck.emit(Unit) } viewModel.requestFileSystemCheck.emit(Unit)
testScheduler.triggerActions() advanceUntilIdle()
runBlocking { books.emit(listOf(bookToRemove)) } books.emit(listOf(bookToRemove))
testScheduler.triggerActions() advanceUntilIdle()
runBlocking { booksOnFileSystem.emit(
booksOnFileSystem.emit( listOf(
listOf( expectedBook,
expectedBook, expectedBook,
expectedBook, bookToRemove
bookToRemove
)
) )
} )
runBlocking { delay(3000) } advanceUntilIdle()
verify { coVerify {
newBookDao.insert(listOf(expectedBook)) newBookDao.insert(listOf(expectedBook))
} }
} }
@ -263,7 +261,7 @@ class ZimManageViewModelTest {
@Nested @Nested
inner class Languages { inner class Languages {
@Test @Test
fun `network no result & empty language db activates the default locale`() { fun `network no result & empty language db activates the default locale`() = runTest {
val expectedLanguage = val expectedLanguage =
Language( Language(
active = true, active = true,
@ -278,11 +276,12 @@ class ZimManageViewModelTest {
listOf(), listOf(),
expectedLanguage expectedLanguage
) )
advanceUntilIdle()
verify { newLanguagesDao.insert(listOf(expectedLanguage)) } verify { newLanguagesDao.insert(listOf(expectedLanguage)) }
} }
@Test @Test
fun `network no result & a language db result triggers nothing`() { fun `network no result & a language db result triggers nothing`() = runTest {
expectNetworkDbAndDefault( expectNetworkDbAndDefault(
listOf(), listOf(),
listOf( listOf(
@ -297,84 +296,87 @@ class ZimManageViewModelTest {
), ),
language(isActive = true, occurencesOfLanguage = 1) language(isActive = true, occurencesOfLanguage = 1)
) )
verify(exactly = 0) { newLanguagesDao.insert(any()) } verify { newLanguagesDao.insert(any()) }
} }
@Test @Test
fun `network result & empty language db triggers combined result of default + network`() { fun `network result & empty language db triggers combined result of default + network`() =
val defaultLanguage = runTest {
Language( val defaultLanguage =
active = true, Language(
occurencesOfLanguage = 1, active = true,
language = "English", occurencesOfLanguage = 1,
languageLocalized = "English", language = "English",
languageCode = "eng", languageLocalized = "English",
languageCodeISO2 = "eng" languageCode = "eng",
) languageCodeISO2 = "eng"
expectNetworkDbAndDefault( )
listOf( expectNetworkDbAndDefault(
book(language = "eng"),
book(language = "eng"),
book(language = "fra")
),
listOf(),
defaultLanguage
)
verify {
newLanguagesDao.insert(
listOf( listOf(
defaultLanguage.copy(occurencesOfLanguage = 2), book(language = "eng"),
Language( book(language = "eng"),
active = false, book(language = "fra")
occurencesOfLanguage = 1, ),
language = "fra", listOf(),
languageLocalized = "", defaultLanguage
languageCode = "", )
languageCodeISO2 = "" verify {
newLanguagesDao.insert(
listOf(
defaultLanguage.copy(occurencesOfLanguage = 2),
Language(
active = false,
occurencesOfLanguage = 1,
language = "fra",
languageLocalized = "",
languageCode = "",
languageCodeISO2 = ""
)
) )
) )
) }
} }
}
@Test @Test
fun `network result & language db results activates a combined network + db result`() { fun `network result & language db results activates a combined network + db result`() =
val dbLanguage = runTest {
Language( val dbLanguage =
active = true, Language(
occurencesOfLanguage = 1, active = true,
language = "English", occurencesOfLanguage = 1,
languageLocalized = "English", language = "English",
languageCode = "eng", languageLocalized = "English",
languageCodeISO2 = "eng" languageCode = "eng",
) languageCodeISO2 = "eng"
expectNetworkDbAndDefault( )
listOf( expectNetworkDbAndDefault(
book(language = "eng"),
book(language = "eng"),
book(language = "fra")
),
listOf(dbLanguage),
language(isActive = true, occurencesOfLanguage = 1)
)
verify {
newLanguagesDao.insert(
listOf( listOf(
dbLanguage.copy(occurencesOfLanguage = 2), book(language = "eng"),
Language( book(language = "eng"),
active = false, book(language = "fra")
occurencesOfLanguage = 1, ),
language = "fra", listOf(dbLanguage),
languageLocalized = "", language(isActive = true, occurencesOfLanguage = 1)
languageCode = "", )
languageCodeISO2 = "" advanceUntilIdle()
verify {
newLanguagesDao.insert(
listOf(
dbLanguage.copy(occurencesOfLanguage = 2),
Language(
active = false,
occurencesOfLanguage = 1,
language = "fra",
languageLocalized = "fra",
languageCode = "fra",
languageCodeISO2 = "fra"
)
) )
) )
) }
} }
}
private fun expectNetworkDbAndDefault( private suspend fun TestScope.expectNetworkDbAndDefault(
networkBooks: List<Book>, networkBooks: List<Book>,
dbBooks: List<Language>, dbBooks: List<Language>,
defaultLanguage: Language defaultLanguage: Language
@ -383,10 +385,12 @@ class ZimManageViewModelTest {
every { application.getString(any(), any()) } returns "" every { application.getString(any(), any()) } returns ""
coEvery { kiwixService.getLibrary() } returns libraryNetworkEntity(networkBooks) coEvery { kiwixService.getLibrary() } returns libraryNetworkEntity(networkBooks)
every { defaultLanguageProvider.provide() } returns defaultLanguage every { defaultLanguageProvider.provide() } returns defaultLanguage
viewModel.networkLibrary.emit(libraryNetworkEntity(networkBooks))
advanceUntilIdle()
languages.value = dbBooks languages.value = dbBooks
testScheduler.triggerActions() advanceUntilIdle()
networkStates.onNext(CONNECTED) networkStates.onNext(CONNECTED)
testScheduler.triggerActions() advanceUntilIdle()
} }
} }
@ -400,46 +404,50 @@ class ZimManageViewModelTest {
} }
@Test @Test
fun `library update removes from sources and maps to list items`() { fun `library update removes from sources and maps to list items`() = runTest {
val bookAlreadyOnDisk = book(id = "0", url = "", language = Locale.ENGLISH.language) val bookAlreadyOnDisk = book(id = "0", url = "", language = Locale.ENGLISH.language)
val bookDownloading = book(id = "1", url = "") val bookDownloading = book(id = "1", url = "")
val bookWithActiveLanguage = book(id = "3", language = "activeLanguage", url = "") val bookWithActiveLanguage = book(id = "3", language = "activeLanguage", url = "")
val bookWithInactiveLanguage = book(id = "4", language = "inactiveLanguage", url = "") val bookWithInactiveLanguage = book(id = "4", language = "inactiveLanguage", url = "")
every { application.getString(any()) } returns "" testFlow(
every { application.getString(any(), any()) } returns "" flow = viewModel.libraryItems,
coEvery { triggerAction = {
kiwixService.getLibrary() every { application.getString(any()) } returns ""
} returns every { application.getString(any(), any()) } returns ""
libraryNetworkEntity( networkStates.onNext(CONNECTED)
listOf( downloads.value = listOf(downloadModel(book = bookDownloading))
bookAlreadyOnDisk, books.value = listOf(bookOnDisk(book = bookAlreadyOnDisk))
bookDownloading, languages.value =
bookWithActiveLanguage, listOf(
bookWithInactiveLanguage language(isActive = true, occurencesOfLanguage = 1, languageCode = "activeLanguage"),
language(isActive = false, occurencesOfLanguage = 1, languageCode = "inactiveLanguage")
)
fileSystemStates.value = CanWrite4GbFile
viewModel.networkLibrary.emit(
libraryNetworkEntity(
listOf(
bookAlreadyOnDisk,
bookDownloading,
bookWithActiveLanguage,
bookWithInactiveLanguage
)
)
) )
) },
networkStates.onNext(CONNECTED) assert = {
downloads.value = listOf(downloadModel(book = bookDownloading)) skipItems(1)
books.value = listOf(bookOnDisk(book = bookAlreadyOnDisk)) assertThat(awaitItem()).isEqualTo(
languages.value = listOf(
listOf( LibraryListItem.DividerItem(Long.MAX_VALUE, R.string.downloading),
language(isActive = true, occurencesOfLanguage = 1, languageCode = "activeLanguage"), LibraryListItem.LibraryDownloadItem(downloadModel(book = bookDownloading)),
language(isActive = false, occurencesOfLanguage = 1, languageCode = "inactiveLanguage") LibraryListItem.DividerItem(Long.MAX_VALUE - 1, R.string.your_languages),
) LibraryListItem.BookItem(bookWithActiveLanguage, CanWrite4GbFile),
fileSystemStates.value = CanWrite4GbFile LibraryListItem.DividerItem(Long.MIN_VALUE, R.string.other_languages),
testScheduler.advanceTimeBy(500, MILLISECONDS) LibraryListItem.BookItem(bookWithInactiveLanguage, CanWrite4GbFile)
testScheduler.triggerActions() )
// viewModel.libraryItems.test() )
// .assertValue( }
// listOf( )
// LibraryListItem.DividerItem(Long.MAX_VALUE, R.string.downloading),
// LibraryListItem.LibraryDownloadItem(downloadModel(book = bookDownloading)),
// LibraryListItem.DividerItem(Long.MAX_VALUE - 1, R.string.your_languages),
// LibraryListItem.BookItem(bookWithActiveLanguage, CanWrite4GbFile),
// LibraryListItem.DividerItem(Long.MIN_VALUE, R.string.other_languages),
// LibraryListItem.BookItem(bookWithInactiveLanguage, CanWrite4GbFile)
// )
// )
} }
@OptIn(ExperimentalCoroutinesApi::class) @OptIn(ExperimentalCoroutinesApi::class)
@ -453,26 +461,29 @@ class ZimManageViewModelTest {
) )
every { application.getString(any()) } returns "" every { application.getString(any()) } returns ""
every { application.getString(any(), any()) } returns "" every { application.getString(any(), any()) } returns ""
coEvery { testFlow(
kiwixService.getLibrary() viewModel.libraryItems,
} returns libraryNetworkEntity(listOf(bookOver4Gb)) triggerAction = {
networkStates.onNext(CONNECTED) networkStates.onNext(CONNECTED)
advanceUntilIdle() downloads.value = listOf()
downloads.value = listOf() books.value = listOf()
books.value = listOf() languages.value =
languages.value = listOf(
listOf( language(isActive = true, occurencesOfLanguage = 1, languageCode = "activeLanguage")
language(isActive = true, occurencesOfLanguage = 1, languageCode = "activeLanguage") )
) fileSystemStates.value = CannotWrite4GbFile
fileSystemStates.value = CannotWrite4GbFile viewModel.networkLibrary.emit(libraryNetworkEntity(listOf(bookOver4Gb)))
testScheduler.advanceTimeBy(500L) },
// viewModel.libraryItems.test() assert = {
// .assertValue( skipItems(1)
// listOf( assertThat(awaitItem()).isEqualTo(
// LibraryListItem.DividerItem(Long.MIN_VALUE, R.string.other_languages), listOf(
// LibraryListItem.BookItem(bookOver4Gb, CannotWrite4GbFile) LibraryListItem.DividerItem(Long.MIN_VALUE, R.string.other_languages),
// ) LibraryListItem.BookItem(bookOver4Gb, CannotWrite4GbFile)
// ) )
)
}
)
} }
@Nested @Nested