#3756 Convert SearchDepictionsFragment to use Pagination (#3758)

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)
     }
-}
+}

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)
     }
 }

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)
     }
 }

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()
+    }
+}

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)
+    }
+}

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()
+    }
+}

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)
-    }
-}

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)
+    }
+}

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()
     }
-}
+}