#3756 Convert SearchDepictionsFragment to use Pagination (#3758)

2025-10-27 21:03:54 +01:00 · 2020-05-28 12:10:04 +01:00 · 2020-05-28 12:10:04 +01:00 · c216fdf0d4
commit c216fdf0d4
parent 0ebd59a223
33 changed files with 1035 additions and 616 deletions
--- a/app/src/test/kotlin/fr/free/nrw/commons/campaigns/CampaignsPresenterTest.kt
+++ b/app/src/test/kotlin/fr/free/nrw/commons/campaigns/CampaignsPresenterTest.kt
@ -15,19 +15,19 @@ import kotlin.collections.ArrayList

 class CampaignsPresenterTest {
    @Mock
-    var okHttpJsonApiClient: OkHttpJsonApiClient? = null
+    lateinit var okHttpJsonApiClient: OkHttpJsonApiClient

    lateinit var campaignsPresenter: CampaignsPresenter

    @Mock
-    internal var view: ICampaignsView? = null
+    internal lateinit var view: ICampaignsView

    @Mock
-    internal var campaignResponseDTO: CampaignResponseDTO? = null
+    internal lateinit var campaignResponseDTO: CampaignResponseDTO
    lateinit var campaignsSingle: Single<CampaignResponseDTO>

    @Mock
-    var campaign: Campaign? = null
+    lateinit var campaign: Campaign

    lateinit var testScheduler: TestScheduler

@ -41,37 +41,37 @@ class CampaignsPresenterTest {
        testScheduler=TestScheduler()
        campaignsSingle= Single.just(campaignResponseDTO)
        campaignsPresenter= CampaignsPresenter(okHttpJsonApiClient,testScheduler,testScheduler)
-        campaignsPresenter?.onAttachView(view)
-        Mockito.`when`(okHttpJsonApiClient?.campaigns).thenReturn(campaignsSingle)
+        campaignsPresenter.onAttachView(view)
+        Mockito.`when`(okHttpJsonApiClient.campaigns).thenReturn(campaignsSingle)
    }

    @Test
    fun getCampaignsTestNoCampaigns() {
        campaignsPresenter.getCampaigns()
-        verify(okHttpJsonApiClient)?.campaigns
+        verify(okHttpJsonApiClient).campaigns
        testScheduler.triggerActions()
-        verify(view)?.showCampaigns(null)
+        verify(view).showCampaigns(null)
    }

    @Test
    fun getCampaignsTestNonEmptyCampaigns() {
        campaignsPresenter.getCampaigns()
        var campaigns= ArrayList<Campaign>()
-        campaigns.add(campaign!!)
+        campaigns.add(campaign)
        val simpleDateFormat = SimpleDateFormat("yyyy-MM-dd", Locale.ROOT)
        simpleDateFormat.timeZone = TimeZone.getTimeZone("UTC")
-        Mockito.`when`(campaignResponseDTO?.campaigns).thenReturn(campaigns)
+        Mockito.`when`(campaignResponseDTO.campaigns).thenReturn(campaigns)
        var calendar = Calendar.getInstance()
        calendar.add(Calendar.DATE,-1)
        val startDateString = simpleDateFormat.format(calendar.time).toString()
        calendar= Calendar.getInstance()
        calendar.add(Calendar.DATE,3)
        val endDateString= simpleDateFormat.format(calendar.time).toString()
-        Mockito.`when`(campaign?.endDate).thenReturn(endDateString)
-        Mockito.`when`(campaign?.startDate).thenReturn(startDateString)
-        Mockito.`when`(campaignResponseDTO?.campaigns).thenReturn(campaigns)
-        verify(okHttpJsonApiClient)?.campaigns
+        Mockito.`when`(campaign.endDate).thenReturn(endDateString)
+        Mockito.`when`(campaign.startDate).thenReturn(startDateString)
+        Mockito.`when`(campaignResponseDTO.campaigns).thenReturn(campaigns)
+        verify(okHttpJsonApiClient).campaigns
        testScheduler.triggerActions()
-        verify(view)?.showCampaigns(campaign)
+        verify(view).showCampaigns(campaign)
    }
-}
+}
--- a/app/src/test/kotlin/fr/free/nrw/commons/depictions/DepictedImagesPresenterTest.kt
+++ b/app/src/test/kotlin/fr/free/nrw/commons/depictions/DepictedImagesPresenterTest.kt
@ -1,6 +1,5 @@
 package fr.free.nrw.commons.depictions

-import org.mockito.Mockito.verify
 import fr.free.nrw.commons.Media
 import fr.free.nrw.commons.depictions.Media.DepictedImagesFragment
 import fr.free.nrw.commons.depictions.Media.DepictedImagesPresenter
@ -15,24 +14,26 @@ import org.junit.Test
 import org.mockito.ArgumentMatchers
 import org.mockito.Mock
 import org.mockito.Mockito
+import org.mockito.Mockito.verify
 import org.mockito.MockitoAnnotations

 class DepictedImagesPresenterTest {

    @Mock
-    internal var view: DepictedImagesFragment? = null
+    internal lateinit var view: DepictedImagesFragment

-    var depictedImagesPresenter: DepictedImagesPresenter? = null
-
-    var jsonKvStore: JsonKvStore? = null
+    lateinit var depictedImagesPresenter: DepictedImagesPresenter

    @Mock
-    var depictsClient: DepictsClient? = null
+    lateinit var jsonKvStore: JsonKvStore

    @Mock
-    var mediaClient: MediaClient? = null
+    lateinit var depictsClient: DepictsClient

-    var testScheduler: TestScheduler? = null
+    @Mock
+    lateinit var mediaClient: MediaClient
+
+    lateinit var testScheduler: TestScheduler

    val mediaList: ArrayList<Media> = ArrayList()

@ -50,24 +51,26 @@ class DepictedImagesPresenterTest {
        mediaList.add(mediaItem)
        testObservable = Observable.just(mediaList)
        depictedImagesPresenter = DepictedImagesPresenter(jsonKvStore, depictsClient, mediaClient, testScheduler, testScheduler)
-        depictedImagesPresenter?.onAttachView(view)
+        depictedImagesPresenter.onAttachView(view)
    }

    @Test
    fun initList() {
-        Mockito.`when`(depictsClient?.fetchImagesForDepictedItem(ArgumentMatchers.anyString(),
-            ArgumentMatchers.anyInt())).thenReturn(testObservable)
-        depictedImagesPresenter?.initList("rabbit")
-        depictedImagesPresenter?.handleSuccess(mediaList)
+        Mockito.`when`(
+            depictsClient.fetchImagesForDepictedItem(ArgumentMatchers.anyString(),
+                ArgumentMatchers.anyInt())
+        ).thenReturn(testObservable)
+        depictedImagesPresenter.initList("rabbit")
+        depictedImagesPresenter.handleSuccess(mediaList)
        verify(view)?.handleSuccess(mediaList)
    }

    @Test
    fun replaceTitlesWithCaptions() {
        var stringObservable: Single<String>? = Single.just(String())
-        Mockito.`when`(mediaClient?.getCaptionByWikibaseIdentifier(ArgumentMatchers.anyString()))?.thenReturn(stringObservable)
-        depictedImagesPresenter?.replaceTitlesWithCaptions("File:rabbit.jpg", 0)
-        testScheduler?.triggerActions()
+        Mockito.`when`(mediaClient.getCaptionByWikibaseIdentifier(ArgumentMatchers.anyString()))?.thenReturn(stringObservable)
+        depictedImagesPresenter.replaceTitlesWithCaptions("File:rabbit.jpg", 0)
+        testScheduler.triggerActions()
        verify(view)?.handleLabelforImage("", 0)
    }
 }
--- a/app/src/test/kotlin/fr/free/nrw/commons/depictions/SubDepictionListPresenterTest.kt
+++ b/app/src/test/kotlin/fr/free/nrw/commons/depictions/SubDepictionListPresenterTest.kt
@ -7,7 +7,6 @@ import fr.free.nrw.commons.explore.recentsearches.RecentSearchesDao
 import fr.free.nrw.commons.mwapi.OkHttpJsonApiClient
 import fr.free.nrw.commons.upload.structure.depictions.DepictedItem
 import io.reactivex.Observable
-import io.reactivex.Single
 import io.reactivex.schedulers.TestScheduler
 import org.junit.Before
 import org.junit.Test
@ -20,19 +19,20 @@ import org.mockito.MockitoAnnotations
 class SubDepictionListPresenterTest {

    @Mock
-    internal var view: SubDepictionListContract.View? = null
+    internal lateinit var view: SubDepictionListContract.View

-    var subDepictionListPresenter: SubDepictionListPresenter? = null
+    lateinit var subDepictionListPresenter: SubDepictionListPresenter

-    var testScheduler: TestScheduler? = null
-
-    internal var recentSearchesDao: RecentSearchesDao? = null
+    lateinit var testScheduler: TestScheduler

    @Mock
-    internal var depictsClient: DepictsClient? = null
+    internal lateinit var recentSearchesDao: RecentSearchesDao

    @Mock
-    internal var okHttpJsonApiClient: OkHttpJsonApiClient? = null
+    internal lateinit var depictsClient: DepictsClient
+
+    @Mock
+    internal lateinit var okHttpJsonApiClient: OkHttpJsonApiClient

    var testObservable: Observable<List<DepictedItem>>? = null

@ -49,22 +49,22 @@ class SubDepictionListPresenterTest {
        depictedItems.add(depictedItem)
        testObservable = Observable.just(depictedItems)
        subDepictionListPresenter = SubDepictionListPresenter(recentSearchesDao, depictsClient, okHttpJsonApiClient, testScheduler, testScheduler)
-        subDepictionListPresenter?.onAttachView(view)
+        subDepictionListPresenter.onAttachView(view)
    }

    @Test
    fun initSubDepictionListForParentClass() {
-        Mockito.`when`(okHttpJsonApiClient?.getParentQIDs(ArgumentMatchers.anyString())).thenReturn(testObservable)
-        subDepictionListPresenter?.initSubDepictionList("Q9394", true)
-        testScheduler?.triggerActions()
+        Mockito.`when`(okHttpJsonApiClient.getParentQIDs(ArgumentMatchers.anyString())).thenReturn(testObservable)
+        subDepictionListPresenter.initSubDepictionList("Q9394", true)
+        testScheduler.triggerActions()
        verify(view)?.onSuccess(depictedItems)
    }

    @Test
    fun initSubDepictionListForChildClass() {
-        Mockito.`when`(okHttpJsonApiClient?.getChildQIDs(ArgumentMatchers.anyString())).thenReturn(testObservable)
-        subDepictionListPresenter?.initSubDepictionList("Q9394", false)
-        testScheduler?.triggerActions()
+        Mockito.`when`(okHttpJsonApiClient.getChildQIDs(ArgumentMatchers.anyString())).thenReturn(testObservable)
+        subDepictionListPresenter.initSubDepictionList("Q9394", false)
+        testScheduler.triggerActions()
        verify(view)?.onSuccess(depictedItems)
    }
 }
--- a/app/src/test/kotlin/fr/free/nrw/commons/explore/depictions/SearchDepictionsDataSourceFactoryTest.kt
+++ b/app/src/test/kotlin/fr/free/nrw/commons/explore/depictions/SearchDepictionsDataSourceFactoryTest.kt
@ -0,0 +1,53 @@
+package fr.free.nrw.commons.explore.depictions
+
+import com.nhaarman.mockitokotlin2.mock
+import com.nhaarman.mockitokotlin2.spy
+import com.nhaarman.mockitokotlin2.verify
+import io.reactivex.processors.PublishProcessor
+import org.hamcrest.MatcherAssert.assertThat
+import org.hamcrest.Matchers.`is`
+import org.junit.Before
+import org.junit.Ignore
+import org.junit.Test
+import org.mockito.Mock
+import org.mockito.Mockito
+import org.mockito.MockitoAnnotations
+
+class SearchDepictionsDataSourceFactoryTest {
+
+    @Mock
+    private lateinit var depictsClient: DepictsClient
+
+    @Mock
+    private lateinit var loadingStates: PublishProcessor<LoadingState>
+    private lateinit var factory: SearchDepictionsDataSourceFactory
+
+    @Before
+    fun setUp() {
+        MockitoAnnotations.initMocks(this)
+        factory = SearchDepictionsDataSourceFactory(depictsClient, "test", loadingStates)
+    }
+
+    @Test
+    fun `create returns a dataSource`() {
+        assertThat(
+            factory.create(),
+            `is`(SearchDepictionsDataSource(depictsClient, loadingStates, "test"))
+        )
+    }
+
+    @Test
+    @Ignore("Rewrite with Mockk constructor mocks")
+    fun `retryFailedRequest invokes method if not null`() {
+        val spyFactory = spy(factory)
+        val dataSource = mock<SearchDepictionsDataSource>()
+        Mockito.doReturn(dataSource).`when`(spyFactory).create()
+        factory.retryFailedRequest()
+        verify(dataSource).retryFailedRequest()
+    }
+
+    @Test
+    fun `retryFailedRequest does not invoke method if null`() {
+        factory.retryFailedRequest()
+    }
+}
--- a/app/src/test/kotlin/fr/free/nrw/commons/explore/depictions/SearchDepictionsDataSourceTest.kt
+++ b/app/src/test/kotlin/fr/free/nrw/commons/explore/depictions/SearchDepictionsDataSourceTest.kt
@ -0,0 +1,106 @@
+package fr.free.nrw.commons.explore.depictions
+
+import androidx.paging.PositionalDataSource
+import com.nhaarman.mockitokotlin2.*
+import fr.free.nrw.commons.explore.depictions.LoadingState.*
+import fr.free.nrw.commons.upload.structure.depictions.DepictedItem
+import io.reactivex.Single
+import io.reactivex.plugins.RxJavaPlugins
+import io.reactivex.processors.PublishProcessor
+import io.reactivex.schedulers.Schedulers
+import org.junit.After
+import org.junit.Before
+import org.junit.Test
+import org.mockito.Mock
+import org.mockito.MockitoAnnotations
+
+class SearchDepictionsDataSourceTest {
+
+    @Mock
+    private lateinit var depictsClient: DepictsClient
+
+    private lateinit var loadingStates: PublishProcessor<LoadingState>
+    private lateinit var searchDepictionsDataSource: SearchDepictionsDataSource
+
+    @Before
+    fun setUp() {
+        RxJavaPlugins.setIoSchedulerHandler { Schedulers.trampoline() }
+        MockitoAnnotations.initMocks(this)
+        loadingStates = PublishProcessor.create()
+        searchDepictionsDataSource =
+            SearchDepictionsDataSource(depictsClient, loadingStates, "test")
+    }
+
+    @After
+    fun tearDown() {
+        RxJavaPlugins.reset()
+    }
+
+    @Test
+    fun `loadInitial returns results and emits InitialLoad & Complete`() {
+        val params = PositionalDataSource.LoadInitialParams(0, 1, 2, false)
+        val callback = mock<PositionalDataSource.LoadInitialCallback<DepictedItem>>()
+        whenever(depictsClient.searchForDepictions("test", 1, 0))
+            .thenReturn(Single.just(emptyList()))
+        val testSubscriber = loadingStates.test()
+        searchDepictionsDataSource.loadInitial(params, callback)
+        verify(callback).onResult(emptyList(), 0)
+        testSubscriber.assertValues(InitialLoad, Complete)
+    }
+
+    @Test
+    fun `loadInitial onError does not return results and emits InitialLoad & Error`() {
+        val params = PositionalDataSource.LoadInitialParams(0, 1, 2, false)
+        val callback = mock<PositionalDataSource.LoadInitialCallback<DepictedItem>>()
+        whenever(depictsClient.searchForDepictions("test", 1, 0))
+            .thenThrow(RuntimeException())
+        val testSubscriber = loadingStates.test()
+        searchDepictionsDataSource.loadInitial(params, callback)
+        verify(callback, never()).onResult(any(), any())
+        testSubscriber.assertValues(InitialLoad, Error)
+    }
+
+    @Test
+    fun `loadRange returns results and emits Loading & Complete`() {
+        val callback: PositionalDataSource.LoadRangeCallback<DepictedItem> = mock()
+        val params = PositionalDataSource.LoadRangeParams(0, 1)
+        whenever(depictsClient.searchForDepictions("test", params.loadSize, params.startPosition))
+            .thenReturn(Single.just(emptyList()))
+        val testSubscriber = loadingStates.test()
+        searchDepictionsDataSource.loadRange(params, callback)
+        verify(callback).onResult(emptyList())
+        testSubscriber.assertValues(Loading, Complete)
+    }
+
+    @Test
+    fun `loadRange onError does not return results and emits Loading & Error`() {
+        val callback: PositionalDataSource.LoadRangeCallback<DepictedItem> = mock()
+        val params = PositionalDataSource.LoadRangeParams(0, 1)
+        whenever(depictsClient.searchForDepictions("test", params.loadSize, params.startPosition))
+            .thenThrow(RuntimeException())
+        val testSubscriber = loadingStates.test()
+        searchDepictionsDataSource.loadRange(params, callback)
+        verify(callback, never()).onResult(any())
+        testSubscriber.assertValues(Loading, Error)
+    }
+
+    @Test
+    fun `retryFailedRequest does nothing when null`() {
+        searchDepictionsDataSource.retryFailedRequest()
+        verifyNoMoreInteractions(depictsClient)
+    }
+
+    @Test
+    fun `retryFailedRequest retries last request`() {
+        val callback: PositionalDataSource.LoadRangeCallback<DepictedItem> = mock()
+        val params = PositionalDataSource.LoadRangeParams(0, 1)
+        whenever(depictsClient.searchForDepictions("test", params.loadSize, params.startPosition))
+            .thenThrow(RuntimeException()).thenReturn(Single.just(emptyList()))
+        val testSubscriber = loadingStates.test()
+        searchDepictionsDataSource.loadRange(params, callback)
+        verify(callback, never()).onResult(any())
+        searchDepictionsDataSource.retryFailedRequest()
+        verify(callback).onResult(emptyList())
+        testSubscriber.assertValues(Loading, Error, Loading, Complete)
+    }
+}
--- a/app/src/test/kotlin/fr/free/nrw/commons/explore/depictions/SearchDepictionsFragmentPresenterTest.kt
+++ b/app/src/test/kotlin/fr/free/nrw/commons/explore/depictions/SearchDepictionsFragmentPresenterTest.kt
@ -0,0 +1,136 @@
+package fr.free.nrw.commons.explore.depictions
+
+import androidx.arch.core.executor.testing.InstantTaskExecutorRule
+import androidx.lifecycle.LiveData
+import androidx.paging.PagedList
+import com.jraska.livedata.test
+import com.nhaarman.mockitokotlin2.*
+import fr.free.nrw.commons.upload.structure.depictions.DepictedItem
+import io.reactivex.processors.PublishProcessor
+import io.reactivex.schedulers.TestScheduler
+import org.junit.Before
+import org.junit.Rule
+import org.junit.Test
+import org.mockito.Mock
+import org.mockito.MockitoAnnotations
+
+class SearchDepictionsFragmentPresenterTest {
+
+    @Rule
+    @JvmField
+    var instantTaskExecutorRule = InstantTaskExecutorRule()
+
+    @Mock
+    internal lateinit var view: SearchDepictionsFragmentContract.View
+
+    private lateinit var searchDepictionsFragmentPresenter: SearchDepictionsFragmentPresenter
+
+    private lateinit var testScheduler: TestScheduler
+
+    @Mock
+    private lateinit var searchableDepictionsDataSourceFactory: SearchableDepictionsDataSourceFactory
+
+    private var loadingStates: PublishProcessor<LoadingState> = PublishProcessor.create()
+
+    private var searchResults: PublishProcessor<LiveData<PagedList<DepictedItem>>> =
+        PublishProcessor.create()
+
+    private var noItemLoadedEvent: PublishProcessor<Unit> = PublishProcessor.create()
+
+    @Before
+    @Throws(Exception::class)
+    fun setUp() {
+        MockitoAnnotations.initMocks(this)
+        whenever(searchableDepictionsDataSourceFactory.searchResults).thenReturn(searchResults)
+        whenever(searchableDepictionsDataSourceFactory.loadingStates).thenReturn(loadingStates)
+        whenever(searchableDepictionsDataSourceFactory.noItemsLoadedEvent)
+            .thenReturn(noItemLoadedEvent)
+        testScheduler = TestScheduler()
+        searchDepictionsFragmentPresenter = SearchDepictionsFragmentPresenter(
+            testScheduler,
+            searchableDepictionsDataSourceFactory
+        )
+        searchDepictionsFragmentPresenter.onAttachView(view)
+    }
+
+    @Test
+    fun `searchResults emission updates the view`() {
+        val pagedListLiveData = mock<LiveData<PagedList<DepictedItem>>>()
+        searchResults.offer(pagedListLiveData)
+        verify(view).observeSearchResults(pagedListLiveData)
+    }
+
+    @Test
+    fun `Loading offers a loading list item`() {
+        onLoadingState(LoadingState.Loading)
+        searchDepictionsFragmentPresenter.listFooterData.test()
+            .assertValue(listOf(FooterItem.LoadingItem))
+    }
+
+    @Test
+    fun `Complete offers an empty list item and hides initial loader`() {
+        onLoadingState(LoadingState.Complete)
+        searchDepictionsFragmentPresenter.listFooterData.test()
+            .assertValue(emptyList())
+        verify(view).hideInitialLoadProgress()
+    }
+
+    @Test
+    fun `InitialLoad shows initial loader`() {
+        onLoadingState(LoadingState.InitialLoad)
+        verify(view).showInitialLoadInProgress()
+    }
+
+    @Test
+    fun `Error offers a refresh list item, hides initial loader and shows error with a set text`() {
+        searchDepictionsFragmentPresenter.onQueryUpdated("test")
+        onLoadingState(LoadingState.Error)
+        verify(view).setEmptyViewText("test")
+        verify(view).showSnackbar()
+        verify(view).hideInitialLoadProgress()
+        searchDepictionsFragmentPresenter.listFooterData.test()
+            .assertValue(listOf(FooterItem.RefreshItem))
+    }
+
+    @Test
+    fun `Error offers a refresh list item, hides initial loader and shows error with a unset text`() {
+        onLoadingState(LoadingState.Error)
+        verify(view, never()).setEmptyViewText(any())
+        verify(view).showSnackbar()
+        verify(view).hideInitialLoadProgress()
+        searchDepictionsFragmentPresenter.listFooterData.test()
+            .assertValue(listOf(FooterItem.RefreshItem))
+    }
+
+    @Test
+    fun `no Items event sets empty view text`() {
+        searchDepictionsFragmentPresenter.onQueryUpdated("test")
+        noItemLoadedEvent.offer(Unit)
+        verify(view).setEmptyViewText("test")
+    }
+
+    @Test
+    fun `retryFailedRequest calls retry`() {
+        searchDepictionsFragmentPresenter.retryFailedRequest()
+        verify(searchableDepictionsDataSourceFactory).retryFailedRequest()
+    }
+
+    @Test
+    fun `onDetachView stops subscriptions`() {
+        searchDepictionsFragmentPresenter.onDetachView()
+        onLoadingState(LoadingState.Loading)
+        searchDepictionsFragmentPresenter.listFooterData.test()
+            .assertValue(emptyList())
+    }
+
+    @Test
+    fun `onQueryUpdated updates dataSourceFactory`() {
+        searchDepictionsFragmentPresenter.onQueryUpdated("test")
+        verify(searchableDepictionsDataSourceFactory).onQueryUpdated("test")
+    }
+
+    private fun onLoadingState(loadingState: LoadingState) {
+        loadingStates.offer(loadingState)
+        testScheduler.triggerActions()
+    }
+}
--- a/app/src/test/kotlin/fr/free/nrw/commons/explore/depictions/SearchDepictionsPresenterTest.kt
+++ b/app/src/test/kotlin/fr/free/nrw/commons/explore/depictions/SearchDepictionsPresenterTest.kt
@ -1,57 +0,0 @@
-package fr.free.nrw.commons.explore.depictions
-
-import com.nhaarman.mockitokotlin2.whenever
-import depictedItem
-import fr.free.nrw.commons.explore.recentsearches.RecentSearchesDao
-import fr.free.nrw.commons.kvstore.JsonKvStore
-import io.reactivex.Single
-import io.reactivex.schedulers.TestScheduler
-import org.junit.Before
-import org.junit.Test
-import org.mockito.Mock
-import org.mockito.Mockito.verify
-import org.mockito.MockitoAnnotations
-
-class SearchDepictionsPresenterTest {
-
-    @Mock
-    internal lateinit var view: SearchDepictionsFragmentContract.View
-
-    private lateinit var searchDepictionsFragmentPresenter: SearchDepictionsFragmentPresenter
-
-    private lateinit var testScheduler: TestScheduler
-
-    @Mock
-    private lateinit var jsonKvStore: JsonKvStore
-
-    @Mock
-    lateinit var recentSearchesDao: RecentSearchesDao
-
-    @Mock
-    lateinit var depictsClient: DepictsClient
-
-    @Before
-    @Throws(Exception::class)
-    fun setUp() {
-        MockitoAnnotations.initMocks(this)
-        testScheduler = TestScheduler()
-        searchDepictionsFragmentPresenter = SearchDepictionsFragmentPresenter(
-            jsonKvStore,
-            recentSearchesDao,
-            depictsClient,
-            testScheduler,
-            testScheduler
-        )
-        searchDepictionsFragmentPresenter.onAttachView(view)
-    }
-
-    @Test
-    fun updateDepictionList() {
-        val expectedList = listOf(depictedItem())
-        whenever(depictsClient.searchForDepictions("rabbit", 25, 0))
-            .thenReturn(Single.just(expectedList))
-        searchDepictionsFragmentPresenter.updateDepictionList("rabbit", 25, false)
-        testScheduler.triggerActions()
-        verify(view)?.onSuccess(expectedList)
-    }
-}
--- a/app/src/test/kotlin/fr/free/nrw/commons/explore/depictions/SearchableDepictionsDataSourceFactoryTest.kt
+++ b/app/src/test/kotlin/fr/free/nrw/commons/explore/depictions/SearchableDepictionsDataSourceFactoryTest.kt
@ -0,0 +1,80 @@
+package fr.free.nrw.commons.explore.depictions
+
+import androidx.lifecycle.LiveData
+import androidx.paging.PagedList
+import com.nhaarman.mockitokotlin2.*
+import fr.free.nrw.commons.upload.structure.depictions.DepictedItem
+import io.reactivex.processors.PublishProcessor
+import org.junit.Before
+import org.junit.Test
+import org.mockito.Mock
+import org.mockito.MockitoAnnotations
+
+class SearchableDepictionsDataSourceFactoryTest {
+
+    @Mock
+    private lateinit var searchDepictionsDataSourceFactoryFactory: SearchDepictionsDataSourceFactoryFactory
+
+    @Mock
+    private lateinit var liveDataConverter: LiveDataConverter
+
+    private lateinit var factory: SearchableDepictionsDataSourceFactory
+
+
+    @Before
+    fun setUp() {
+        MockitoAnnotations.initMocks(this)
+        factory = SearchableDepictionsDataSourceFactory(
+            searchDepictionsDataSourceFactoryFactory,
+            liveDataConverter
+        )
+    }
+
+    @Test
+    fun `onQueryUpdated emits new liveData`() {
+        val (_, liveData) = expectNewLiveData()
+        factory.searchResults.test()
+            .also { factory.onQueryUpdated("test") }
+            .assertValue(liveData)
+    }
+
+    @Test
+    fun `onQueryUpdated invokes livedatconverter with no items emitter`() {
+        val (captor, _) = expectNewLiveData()
+        factory.onQueryUpdated("test")
+        factory.noItemsLoadedEvent.test()
+            .also { captor.firstValue.invoke() }
+            .assertValue(Unit)
+    }
+
+    /*
+    * Just for coverage, no way to really assert this
+    * */
+    @Test
+    fun `retryFailedRequest does nothing without a factory`() {
+        factory.retryFailedRequest()
+    }
+
+    @Test
+    fun `retryFailedRequest retries with a factory`() {
+        val (_, _, dataSourceFactory) = expectNewLiveData()
+        factory.onQueryUpdated("test")
+        factory.retryFailedRequest()
+        verify(dataSourceFactory).retryFailedRequest()
+    }
+
+    private fun expectNewLiveData(): Triple<KArgumentCaptor<() -> Unit>, LiveData<PagedList<DepictedItem>>, SearchDepictionsDataSourceFactory> {
+        val dataSourceFactory: SearchDepictionsDataSourceFactory = mock()
+        whenever(
+            searchDepictionsDataSourceFactoryFactory.create(
+                "test",
+                factory.loadingStates as PublishProcessor<LoadingState>
+            )
+        ).thenReturn(dataSourceFactory)
+        val captor = argumentCaptor<() -> Unit>()
+        val liveData: LiveData<PagedList<DepictedItem>> = mock()
+        whenever(liveDataConverter.convert(eq(dataSourceFactory), captor.capture()))
+            .thenReturn(liveData)
+        return Triple(captor, liveData, dataSourceFactory)
+    }
+}
--- a/app/src/test/kotlin/fr/free/nrw/commons/upload/UploadPresenterTest.kt
+++ b/app/src/test/kotlin/fr/free/nrw/commons/upload/UploadPresenterTest.kt
@ -12,7 +12,7 @@ import org.mockito.InjectMocks
 import org.mockito.Mock
 import org.mockito.Mockito.`when`
 import org.mockito.MockitoAnnotations
-import java.util.ArrayList
+import java.util.*


 /**
@ -21,11 +21,11 @@ import java.util.ArrayList
 class UploadPresenterTest {

    @Mock
-    internal var repository: UploadRepository? = null
+    internal lateinit var repository: UploadRepository
    @Mock
-    internal var view: UploadContract.View? = null
+    internal lateinit var view: UploadContract.View
    @Mock
-    var contribution: Contribution? = null
+    lateinit var contribution: Contribution

    @Mock
    private lateinit var uploadableFile: UploadableFile
@ -34,7 +34,7 @@ class UploadPresenterTest {
    private lateinit var anotherUploadableFile: UploadableFile

    @InjectMocks
-    var uploadPresenter: UploadPresenter? = null
+    lateinit var uploadPresenter: UploadPresenter

    private var uploadableFiles: ArrayList<UploadableFile> = ArrayList()

@ -45,11 +45,11 @@ class UploadPresenterTest {
    @Throws(Exception::class)
    fun setUp() {
        MockitoAnnotations.initMocks(this)
-        uploadPresenter?.onAttachView(view)
-        `when`(repository?.buildContributions()).thenReturn(Observable.just(contribution))
+        uploadPresenter.onAttachView(view)
+        `when`(repository.buildContributions()).thenReturn(Observable.just(contribution))
        uploadableFiles.add(uploadableFile)
-        `when`(view?.uploadableFiles).thenReturn(uploadableFiles)
-        `when`(uploadableFile?.filePath).thenReturn("data://test")
+        `when`(view.uploadableFiles).thenReturn(uploadableFiles)
+        `when`(uploadableFile.filePath).thenReturn("data://test")
    }

    /**
@ -57,12 +57,12 @@ class UploadPresenterTest {
     */
    @Test
    fun handleSubmitTestUserLoggedIn() {
-        `when`(view?.isLoggedIn).thenReturn(true)
-        uploadPresenter?.handleSubmit()
-        verify(view)?.isLoggedIn
-        verify(view)?.showProgress(true)
-        verify(repository)?.buildContributions()
-        verify(repository)?.buildContributions()
+        `when`(view.isLoggedIn).thenReturn(true)
+        uploadPresenter.handleSubmit()
+        verify(view).isLoggedIn
+        verify(view).showProgress(true)
+        verify(repository).buildContributions()
+        verify(repository).buildContributions()
    }

    /**
@ -70,10 +70,10 @@ class UploadPresenterTest {
     */
    @Test
    fun handleSubmitTestUserNotLoggedIn() {
-        `when`(view?.isLoggedIn).thenReturn(false)
-        uploadPresenter?.handleSubmit()
-        verify(view)?.isLoggedIn
-        verify(view)?.askUserToLogIn()
+        `when`(view.isLoggedIn).thenReturn(false)
+        uploadPresenter.handleSubmit()
+        verify(view).isLoggedIn
+        verify(view).askUserToLogIn()

    }

@ -88,9 +88,9 @@ class UploadPresenterTest {
    fun hideTopCardWhenReachedTheLastFile(){
        deletePictureBaseTest()
        uploadableFiles.add(uploadableFile)
-        uploadPresenter?.deletePictureAtIndex(0)
-        verify(view)?.showHideTopCard(false)
-        verify(repository)?.deletePicture(ArgumentMatchers.anyString())
+        uploadPresenter.deletePictureAtIndex(0)
+        verify(view).showHideTopCard(false)
+        verify(repository).deletePicture(ArgumentMatchers.anyString())
    }

    /**
@ -100,11 +100,11 @@ class UploadPresenterTest {
    fun testDeleteWhenSingleUpload(){
        deletePictureBaseTest()
        uploadableFiles.add(uploadableFile)
-        uploadPresenter?.deletePictureAtIndex(0)
-        verify(view)?.showHideTopCard(false)
-        verify(repository)?.deletePicture(ArgumentMatchers.anyString())
-        verify(view)?.showMessage(ArgumentMatchers.anyInt())//As there is only one while which we are asking for deletion, upload should be cancelled and this flow should be triggered
-        verify(view)?.finish()
+        uploadPresenter.deletePictureAtIndex(0)
+        verify(view).showHideTopCard(false)
+        verify(repository).deletePicture(ArgumentMatchers.anyString())
+        verify(view).showMessage(ArgumentMatchers.anyInt())//As there is only one while which we are asking for deletion, upload should be cancelled and this flow should be triggered
+        verify(view).finish()
    }

    /**
@ -115,8 +115,8 @@ class UploadPresenterTest {
        deletePictureBaseTest()
        uploadableFiles.add(uploadableFile)
        uploadableFiles.add(anotherUploadableFile)
-        uploadPresenter?.deletePictureAtIndex(0)
-        verify(view)?.onUploadMediaDeleted(0)
-        verify(view)?.updateTopCardTitle()
+        uploadPresenter.deletePictureAtIndex(0)
+        verify(view).onUploadMediaDeleted(0)
+        verify(view).updateTopCardTitle()
    }
-}
+}