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.

* 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.

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

@@ -145,7 +145,7 @@ class OnlineLibraryFragment : BaseFragment(), FragmentActivityExtensions {
 
   private fun onSearchClear() {
     onlineLibraryScreenState.value.update {
-      copy(searchText = "", scanningProgressItem = false to "", isRefreshing = true)
+      copy(searchText = "")
     }
     zimManageViewModel.onlineBooksSearchedQuery.value = null
     zimManageViewModel.requestFiltering.tryEmit("")
@@ -159,7 +159,7 @@ class OnlineLibraryFragment : BaseFragment(), FragmentActivityExtensions {
       zimManageViewModel.onlineBooksSearchedQuery.value = searchText
     }
     onlineLibraryScreenState.value.update {
-      copy(searchText = searchText, scanningProgressItem = false to "", isRefreshing = true)
+      copy(searchText = searchText)
     }
     zimManageViewModel.requestFiltering.tryEmit(searchText)
   }
@@ -248,19 +248,39 @@ class OnlineLibraryFragment : BaseFragment(), FragmentActivityExtensions {
       )
       DialogHost(alertDialogShower)
     }
-    zimManageViewModel.libraryItems
+    observeViewModelData()
+    showPreviouslySearchedTextInSearchView()
+    startDownloadingLibrary()
+  }
+
+  private fun observeViewModelData() {
+    zimManageViewModel.apply {
+      // Observe when library items changes.
+      libraryItems
         .onEach { onLibraryItemsChange(it) }
         .launchIn(viewLifecycleOwner.lifecycleScope)
         .also {
           coreMainActivity.navHostContainer
             .setBottomMarginToFragmentContainerView(0)
         }
-    zimManageViewModel.libraryListIsRefreshing.observe(
+      // 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, true) }
+        Observer { onRefreshStateChange(it) }
       )
-    zimManageViewModel.networkStates.observe(viewLifecycleOwner, Observer(::onNetworkStateChange))
+      // Observe network changes.
-    zimManageViewModel.shouldShowWifiOnlyDialog.observe(
+      networkStates.observe(viewLifecycleOwner, Observer(::onNetworkStateChange))
+      // Observe `shouldShowWifiOnlyDialog` should show.
+      shouldShowWifiOnlyDialog.observe(
         viewLifecycleOwner
       ) {
         if (it && !NetworkUtils.isWiFi(requireContext())) {
@@ -268,9 +288,9 @@ class OnlineLibraryFragment : BaseFragment(), FragmentActivityExtensions {
           hideProgressBarOfFetchingOnlineLibrary()
         }
       }
-    zimManageViewModel.downloadProgress.observe(viewLifecycleOwner, ::onLibraryStatusChanged)
+      // Observe the download progress.
-    showPreviouslySearchedTextInSearchView()
+      downloadProgress.observe(viewLifecycleOwner, ::onLibraryStatusChanged)
-    startDownloadingLibrary()
+    }
   }
 
   private fun showPreviouslySearchedTextInSearchView() {
@@ -365,18 +385,15 @@ class OnlineLibraryFragment : BaseFragment(), FragmentActivityExtensions {
     onlineLibraryScreenState.value.update {
       copy(noContentViewItem = "" to false)
     }
-    showProgressBarOfFetchingOnlineLibrary()
   }
 
   private fun hideRecyclerviewAndShowSwipeDownForLibraryErrorText() {
     onlineLibraryScreenState.value.update {
       copy(noContentViewItem = getString(string.swipe_down_for_library) to true)
     }
-    hideProgressBarOfFetchingOnlineLibrary()
   }
 
   private fun showProgressBarOfFetchingOnlineLibrary() {
-    onRefreshStateChange(isRefreshing = false, shouldShowScanningProgressItem = false)
     onlineLibraryScreenState.value.update {
       copy(
         noContentViewItem = "" to false,
@@ -387,7 +404,6 @@ class OnlineLibraryFragment : BaseFragment(), FragmentActivityExtensions {
   }
 
   private fun hideProgressBarOfFetchingOnlineLibrary() {
-    onRefreshStateChange(isRefreshing = false, false)
     onlineLibraryScreenState.value.update {
       copy(
         isRefreshing = false,
@@ -428,35 +444,29 @@ class OnlineLibraryFragment : BaseFragment(), FragmentActivityExtensions {
     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 {
-      copy(
+      copy(isRefreshing = refreshing)
-        isRefreshing = refreshing,
-        scanningProgressItem = shouldShowScanningProgressItem to onlineLibraryState.scanningProgressItem.second
-      )
     }
   }
 
   private fun onNetworkStateChange(networkState: NetworkState?) {
     when (networkState) {
       NetworkState.CONNECTED -> {
-        if (NetworkUtils.isWiFi(requireContext())) {
+        when {
+          NetworkUtils.isWiFi(requireContext()) -> {
+            if (!zimManageViewModel.isOnlineLibraryDownloading) {
               refreshFragment(false)
-        } else if (noWifiWithWifiOnlyPreferenceSet) {
+            }
+          }
+
+          noWifiWithWifiOnlyPreferenceSet -> {
             hideRecyclerviewAndShowSwipeDownForLibraryErrorText()
-        } else if (!noWifiWithWifiOnlyPreferenceSet) {
+          }
-          if (onlineLibraryScreenState.value.value.onlineLibraryList?.isEmpty() == true) {
+
+          onlineLibraryScreenState.value.value.onlineLibraryList.isNullOrEmpty() &&
+            !zimManageViewModel.isOnlineLibraryDownloading -> {
             startDownloadingLibrary(true)
             showProgressBarOfFetchingOnlineLibrary()
           }

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

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

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

@@ -23,29 +23,32 @@ import android.net.ConnectivityManager
 import android.net.NetworkCapabilities
 import android.net.NetworkCapabilities.TRANSPORT_WIFI
 import android.os.Build
+import androidx.lifecycle.asFlow
 import app.cash.turbine.TurbineTestContext
 import app.cash.turbine.test
 import com.jraska.livedata.test
 import io.mockk.clearAllMocks
 import io.mockk.coEvery
+import io.mockk.coVerify
 import io.mockk.every
 import io.mockk.mockk
 import io.mockk.verify
 import io.reactivex.processors.PublishProcessor
-import io.reactivex.schedulers.TestScheduler
+import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.ExperimentalCoroutinesApi
-import kotlinx.coroutines.delay
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.test.StandardTestDispatcher
 import kotlinx.coroutines.test.TestScope
 import kotlinx.coroutines.test.advanceUntilIdle
+import kotlinx.coroutines.test.resetMain
 import kotlinx.coroutines.test.runTest
+import kotlinx.coroutines.test.setMain
 import org.assertj.core.api.Assertions.assertThat
 import org.junit.jupiter.api.AfterAll
 import org.junit.jupiter.api.BeforeEach
-import org.junit.jupiter.api.Disabled
 import org.junit.jupiter.api.Nested
 import org.junit.jupiter.api.Test
 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.language
 import org.kiwix.sharedFunctions.libraryNetworkEntity
-import org.kiwix.sharedFunctions.resetSchedulers
-import org.kiwix.sharedFunctions.setScheduler
 import java.util.Locale
-import java.util.concurrent.TimeUnit.MILLISECONDS
 
+@OptIn(ExperimentalCoroutinesApi::class)
 @ExtendWith(InstantExecutorExtension::class)
 class ZimManageViewModelTest {
   private val downloadRoomDao: DownloadRoomDao = mockk()
@@ -126,24 +127,20 @@ class ZimManageViewModelTest {
     MutableStateFlow<FileSystemState>(FileSystemState.DetectingFileSystem)
   private val networkStates: PublishProcessor<NetworkState> = PublishProcessor.create()
   private val booksOnDiskListItems = MutableStateFlow<List<BooksOnDiskListItem>>(emptyList())
+  private val testDispatcher = StandardTestDispatcher()
 
-  private val testScheduler = TestScheduler()
-
-  init {
-    setScheduler(testScheduler)
-  }
-
-  @OptIn(ExperimentalCoroutinesApi::class)
   @AfterAll
   fun teardown() {
+    Dispatchers.resetMain()
     viewModel.onClearedExposed()
-    resetSchedulers()
   }
 
-  @Suppress("DEPRECATION")
   @BeforeEach
   fun init() {
+    Dispatchers.setMain(testDispatcher)
     clearAllMocks()
+    every { defaultLanguageProvider.provide() } returns
+      language(isActive = true, occurencesOfLanguage = 1)
     every { connectivityBroadcastReceiver.action } returns "test"
     every { downloadRoomDao.downloads() } returns downloads
     every { newBookDao.books() } returns books
@@ -166,6 +163,13 @@ class ZimManageViewModelTest {
       connectivityManager.getNetworkCapabilities(connectivityManager.activeNetwork)
     } returns networkCapabilities
     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 =
       ZimManageViewModel(
         downloadRoomDao,
@@ -185,7 +189,8 @@ class ZimManageViewModelTest {
         setIsUnitTestCase()
         setAlertDialogShower(alertDialogShower)
       }
-    testScheduler.triggerActions()
+    viewModel.fileSelectListStates.value = FileSelectListState(emptyList())
+    runBlocking { viewModel.networkLibrary.emit(libraryNetworkEntity()) }
   }
 
   @Nested
@@ -216,35 +221,29 @@ class ZimManageViewModelTest {
 
   @Nested
   inner class Books {
-    @OptIn(ExperimentalCoroutinesApi::class)
     @Test
     fun `emissions from data source are observed`() = runTest {
       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)
+          assertThat(awaitItem()).isEqualTo(FileSelectListState(expectedList))
         }
-      viewModel.fileSelectListStates.test()
+      )
-        .assertValue(FileSelectListState(expectedList))
     }
 
-    @OptIn(ExperimentalCoroutinesApi::class)
     @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 ""
       val expectedBook = bookOnDisk(1L, book("1"))
       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(
         listOf(
           expectedBook,
@@ -252,9 +251,8 @@ class ZimManageViewModelTest {
           bookToRemove
         )
       )
-      }
+      advanceUntilIdle()
-      runBlocking { delay(3000) }
+      coVerify {
-      verify {
         newBookDao.insert(listOf(expectedBook))
       }
     }
@@ -263,7 +261,7 @@ class ZimManageViewModelTest {
   @Nested
   inner class Languages {
     @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 =
         Language(
           active = true,
@@ -278,11 +276,12 @@ class ZimManageViewModelTest {
         listOf(),
         expectedLanguage
       )
+      advanceUntilIdle()
       verify { newLanguagesDao.insert(listOf(expectedLanguage)) }
     }
 
     @Test
-    fun `network no result & a language db result triggers nothing`() {
+    fun `network no result & a language db result triggers nothing`() = runTest {
       expectNetworkDbAndDefault(
         listOf(),
         listOf(
@@ -297,11 +296,12 @@ class ZimManageViewModelTest {
         ),
         language(isActive = true, occurencesOfLanguage = 1)
       )
-      verify(exactly = 0) { newLanguagesDao.insert(any()) }
+      verify { newLanguagesDao.insert(any()) }
     }
 
     @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`() =
+      runTest {
         val defaultLanguage =
           Language(
             active = true,
@@ -338,7 +338,8 @@ class ZimManageViewModelTest {
       }
 
     @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`() =
+      runTest {
         val dbLanguage =
           Language(
             active = true,
@@ -357,6 +358,7 @@ class ZimManageViewModelTest {
           listOf(dbLanguage),
           language(isActive = true, occurencesOfLanguage = 1)
         )
+        advanceUntilIdle()
         verify {
           newLanguagesDao.insert(
             listOf(
@@ -365,16 +367,16 @@ class ZimManageViewModelTest {
                 active = false,
                 occurencesOfLanguage = 1,
                 language = "fra",
-              languageLocalized = "",
+                languageLocalized = "fra",
-              languageCode = "",
+                languageCode = "fra",
-              languageCodeISO2 = ""
+                languageCodeISO2 = "fra"
               )
             )
           )
         }
       }
 
-    private fun expectNetworkDbAndDefault(
+    private suspend fun TestScope.expectNetworkDbAndDefault(
       networkBooks: List<Book>,
       dbBooks: List<Language>,
       defaultLanguage: Language
@@ -383,10 +385,12 @@ class ZimManageViewModelTest {
       every { application.getString(any(), any()) } returns ""
       coEvery { kiwixService.getLibrary() } returns libraryNetworkEntity(networkBooks)
       every { defaultLanguageProvider.provide() } returns defaultLanguage
+      viewModel.networkLibrary.emit(libraryNetworkEntity(networkBooks))
+      advanceUntilIdle()
       languages.value = dbBooks
-      testScheduler.triggerActions()
+      advanceUntilIdle()
       networkStates.onNext(CONNECTED)
-      testScheduler.triggerActions()
+      advanceUntilIdle()
     }
   }
 
@@ -400,24 +404,16 @@ class ZimManageViewModelTest {
   }
 
   @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 bookDownloading = book(id = "1", url = "")
     val bookWithActiveLanguage = book(id = "3", language = "activeLanguage", url = "")
     val bookWithInactiveLanguage = book(id = "4", language = "inactiveLanguage", url = "")
+    testFlow(
+      flow = viewModel.libraryItems,
+      triggerAction = {
         every { application.getString(any()) } returns ""
         every { application.getString(any(), any()) } returns ""
-    coEvery {
-      kiwixService.getLibrary()
-    } returns
-      libraryNetworkEntity(
-        listOf(
-          bookAlreadyOnDisk,
-          bookDownloading,
-          bookWithActiveLanguage,
-          bookWithInactiveLanguage
-        )
-      )
         networkStates.onNext(CONNECTED)
         downloads.value = listOf(downloadModel(book = bookDownloading))
         books.value = listOf(bookOnDisk(book = bookAlreadyOnDisk))
@@ -427,19 +423,31 @@ class ZimManageViewModelTest {
             language(isActive = false, occurencesOfLanguage = 1, languageCode = "inactiveLanguage")
           )
         fileSystemStates.value = CanWrite4GbFile
-    testScheduler.advanceTimeBy(500, MILLISECONDS)
+        viewModel.networkLibrary.emit(
-    testScheduler.triggerActions()
+          libraryNetworkEntity(
-    // viewModel.libraryItems.test()
+            listOf(
-    //   .assertValue(
+              bookAlreadyOnDisk,
-    //     listOf(
+              bookDownloading,
-    //       LibraryListItem.DividerItem(Long.MAX_VALUE, R.string.downloading),
+              bookWithActiveLanguage,
-    //       LibraryListItem.LibraryDownloadItem(downloadModel(book = bookDownloading)),
+              bookWithInactiveLanguage
-    //       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)
+      },
-    //     )
+      assert = {
-    //   )
+        skipItems(1)
+        assertThat(awaitItem()).isEqualTo(
+          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)
@@ -453,11 +461,10 @@ class ZimManageViewModelTest {
       )
     every { application.getString(any()) } returns ""
     every { application.getString(any(), any()) } returns ""
-    coEvery {
+    testFlow(
-      kiwixService.getLibrary()
+      viewModel.libraryItems,
-    } returns libraryNetworkEntity(listOf(bookOver4Gb))
+      triggerAction = {
         networkStates.onNext(CONNECTED)
-    advanceUntilIdle()
         downloads.value = listOf()
         books.value = listOf()
         languages.value =
@@ -465,14 +472,18 @@ class ZimManageViewModelTest {
             language(isActive = true, occurencesOfLanguage = 1, languageCode = "activeLanguage")
           )
         fileSystemStates.value = CannotWrite4GbFile
-    testScheduler.advanceTimeBy(500L)
+        viewModel.networkLibrary.emit(libraryNetworkEntity(listOf(bookOver4Gb)))
-    // viewModel.libraryItems.test()
+      },
-    //   .assertValue(
+      assert = {
-    //     listOf(
+        skipItems(1)
-    //       LibraryListItem.DividerItem(Long.MIN_VALUE, R.string.other_languages),
+        assertThat(awaitItem()).isEqualTo(
-    //       LibraryListItem.BookItem(bookOver4Gb, CannotWrite4GbFile)
+          listOf(
-    //     )
+            LibraryListItem.DividerItem(Long.MIN_VALUE, R.string.other_languages),
-    //   )
+            LibraryListItem.BookItem(bookOver4Gb, CannotWrite4GbFile)
+          )
+        )
+      }
+    )
   }
 
   @Nested