#3734 Refactor and convert CategoryPresenter to kotlin (#3735)

app/src/test/kotlin/fr/free/nrw/commons/category/CategoriesModelTest.kt

@@ -2,14 +2,11 @@ package fr.free.nrw.commons.category
 
 import com.nhaarman.mockitokotlin2.mock
 import com.nhaarman.mockitokotlin2.whenever
-import fr.free.nrw.commons.kvstore.JsonKvStore
 import fr.free.nrw.commons.upload.GpsCategoryModel
 import io.reactivex.Observable
-import junit.framework.Assert.assertEquals
+import io.reactivex.subjects.BehaviorSubject
 import org.junit.Before
 import org.junit.Test
-import org.mockito.ArgumentMatchers.anyString
-import org.mockito.ArgumentMatchers.eq
 import org.mockito.Mock
 import org.mockito.MockitoAnnotations
 
@@ -31,48 +28,41 @@ class CategoriesModelTest {
     // Test Case for verifying that Categories search (MW api calls) are case-insensitive
     @Test
     fun searchAllFoundCaseTest() {
-        val categoriesModel = CategoriesModel(categoryClient, null, null, mock())
+        val categoriesModel = CategoriesModel(categoryClient, mock(), mock())
 
-        whenever(categoryClient.searchCategoriesForPrefix(anyString(), eq(25)))
-            .thenReturn(Observable.just("Test"))
+        val expectedList = listOf("Test")
+        whenever(categoryClient.searchCategoriesForPrefix("tes", 25))
+            .thenReturn(Observable.just(expectedList))
 
         // Checking if both return "Test"
-        val actualCategoryName = categoriesModel.searchAll("tes", null).blockingFirst()
-        assertEquals("Test", actualCategoryName.name)
+        val expectedItems = expectedList.map { CategoryItem(it, false) }
+        categoriesModel.searchAll("tes", emptyList())
+            .test()
+            .assertValues(expectedItems)
 
-        val actualCategoryNameCaps = categoriesModel.searchAll("Tes", null).blockingFirst()
-        assertEquals("Test", actualCategoryNameCaps.name)
+        categoriesModel.searchAll("Tes", emptyList())
+            .test()
+            .assertValues(expectedItems)
     }
 
-    /**
-     * For testing the substring search algorithm for Categories search
-     * To be more precise it tests the In Between substring( ex: searching `atte`
-     * will give search suggestions: `Latte`, `Iced latte` e.t.c) which has been described
-     * on github repo wiki:
-     * https://github.com/commons-app/apps-android-commons/wiki/Category-suggestions-(readme)#user-content-3-category-search-when-typing-in-the-search-field-has-been-made-more-flexible
-     */
     @Test
-    fun searchAllFoundCaseTestForSubstringSearch() {
+    fun `searchAll with empty search terms creates results from gps, title search & recents`() {
         val gpsCategoryModel: GpsCategoryModel = mock()
-        val kvStore: JsonKvStore = mock()
 
-        whenever(gpsCategoryModel.categoryList).thenReturn(listOf("gpsCategory"))
+        whenever(gpsCategoryModel.categoriesFromLocation)
+            .thenReturn(BehaviorSubject.createDefault(listOf("gpsCategory")))
         whenever(categoryClient.searchCategories("tes", 25))
-            .thenReturn(Observable.just("tes"))
-        whenever(kvStore.getString("Category", "")).thenReturn("Random Value")
+            .thenReturn(Observable.just(listOf("titleSearch")))
         whenever(categoryDao.recentCategories(25)).thenReturn(listOf("recentCategories"))
-        CategoriesModel(
-            categoryClient,
-            categoryDao,
-            kvStore,
-            gpsCategoryModel
-        ).searchAll(null, listOf("tes"))
+        CategoriesModel(categoryClient, categoryDao, gpsCategoryModel)
+            .searchAll("", listOf("tes"))
             .test()
-            .assertValues(
-                CategoryItem("gpsCategory", false),
-                CategoryItem("tes", false),
-                CategoryItem("Random Value", false),
-                CategoryItem("recentCategories", false)
+            .assertValue(
+                listOf(
+                    CategoryItem("gpsCategory", false),
+                    CategoryItem("titleSearch", false),
+                    CategoryItem("recentCategories", false)
+                )
             )
     }
 }

app/src/test/kotlin/fr/free/nrw/commons/category/CategoryClientTest.kt

@@ -1,20 +1,26 @@
 package fr.free.nrw.commons.category
 
+import com.nhaarman.mockitokotlin2.mock
+import com.nhaarman.mockitokotlin2.whenever
 import io.reactivex.Observable
-import junit.framework.Assert.*
 import org.junit.Before
 import org.junit.Test
-import org.mockito.*
+import org.mockito.ArgumentMatchers.anyInt
+import org.mockito.ArgumentMatchers.anyString
+import org.mockito.InjectMocks
+import org.mockito.Mock
+import org.mockito.Mockito.mock
+import org.mockito.MockitoAnnotations
 import org.wikipedia.dataclient.mwapi.MwQueryPage
 import org.wikipedia.dataclient.mwapi.MwQueryResponse
 import org.wikipedia.dataclient.mwapi.MwQueryResult
 
 class CategoryClientTest {
     @Mock
-    internal var categoryInterface: CategoryInterface? = null
+    internal lateinit var categoryInterface: CategoryInterface
 
     @InjectMocks
-    var categoryClient: CategoryClient? = null
+    lateinit var categoryClient: CategoryClient
 
     @Before
     @Throws(Exception::class)
@@ -24,132 +30,111 @@ class CategoryClientTest {
 
     @Test
     fun searchCategoriesFound() {
-        val mwQueryPage = Mockito.mock(MwQueryPage::class.java)
-        Mockito.`when`(mwQueryPage.title()).thenReturn("Category:Test")
-        val mwQueryResult = Mockito.mock(MwQueryResult::class.java)
-        Mockito.`when`(mwQueryResult.pages()).thenReturn(listOf(mwQueryPage))
-        val mockResponse = Mockito.mock(MwQueryResponse::class.java)
-        Mockito.`when`(mockResponse.query()).thenReturn(mwQueryResult)
-
-        Mockito.`when`(categoryInterface!!.searchCategories(ArgumentMatchers.anyString(), ArgumentMatchers.anyInt(), ArgumentMatchers.anyInt()))
-                .thenReturn(Observable.just(mockResponse))
-
-        val actualCategoryName = categoryClient!!.searchCategories("tes", 10).blockingFirst()
-        assertEquals("Test", actualCategoryName)
-
-        val actualCategoryName2 = categoryClient!!.searchCategories("tes", 10, 10).blockingFirst()
-        assertEquals("Test", actualCategoryName2)
+        val mockResponse = withMockResponse("Category:Test")
+        whenever(categoryInterface.searchCategories(anyString(), anyInt(), anyInt()))
+            .thenReturn(Observable.just(mockResponse))
+        categoryClient.searchCategories("tes", 10)
+            .test()
+            .assertValues(listOf("Test"))
+        categoryClient.searchCategories("tes", 10, 10)
+            .test()
+            .assertValues(listOf("Test"))
     }
 
     @Test
     fun searchCategoriesNull() {
-        val mwQueryResult = Mockito.mock(MwQueryResult::class.java)
-        Mockito.`when`(mwQueryResult.pages()).thenReturn(null)
-        val mockResponse = Mockito.mock(MwQueryResponse::class.java)
-        Mockito.`when`(mockResponse.query()).thenReturn(mwQueryResult)
-
-        Mockito.`when`(categoryInterface!!.searchCategories(ArgumentMatchers.anyString(), ArgumentMatchers.anyInt(), ArgumentMatchers.anyInt()))
-                .thenReturn(Observable.just(mockResponse))
-
-        categoryClient!!.searchCategories("tes", 10).subscribe(
-                { fail("SearchCategories returned element when it shouldn't have.") },
-                { s -> throw s })
-        categoryClient!!.searchCategories("tes", 10, 10).subscribe(
-                { fail("SearchCategories returned element when it shouldn't have.") },
-                { s -> throw s })
+        val mockResponse = withNullPages()
+        whenever(categoryInterface.searchCategories(anyString(), anyInt(), anyInt()))
+            .thenReturn(Observable.just(mockResponse))
+        categoryClient.searchCategories("tes", 10)
+            .test()
+            .assertValues(emptyList())
+        categoryClient.searchCategories("tes", 10, 10)
+            .test()
+            .assertValues(emptyList())
     }
 
     @Test
     fun searchCategoriesForPrefixFound() {
-        val mwQueryPage = Mockito.mock(MwQueryPage::class.java)
-        Mockito.`when`(mwQueryPage.title()).thenReturn("Category:Test")
-        val mwQueryResult = Mockito.mock(MwQueryResult::class.java)
-        Mockito.`when`(mwQueryResult.pages()).thenReturn(listOf(mwQueryPage))
-        val mockResponse = Mockito.mock(MwQueryResponse::class.java)
-        Mockito.`when`(mockResponse.query()).thenReturn(mwQueryResult)
-
-        Mockito.`when`(categoryInterface!!.searchCategoriesForPrefix(ArgumentMatchers.anyString(), ArgumentMatchers.anyInt(), ArgumentMatchers.anyInt()))
-                .thenReturn(Observable.just(mockResponse))
-
-        val actualCategoryName = categoryClient!!.searchCategoriesForPrefix("tes", 10).blockingFirst()
-        assertEquals("Test", actualCategoryName)
-        val actualCategoryName2 = categoryClient!!.searchCategoriesForPrefix("tes", 10, 10).blockingFirst()
-        assertEquals("Test", actualCategoryName2)
+        val mockResponse = withMockResponse("Category:Test")
+        whenever(categoryInterface.searchCategoriesForPrefix(anyString(), anyInt(), anyInt()))
+            .thenReturn(Observable.just(mockResponse))
+        categoryClient.searchCategoriesForPrefix("tes", 10)
+            .test()
+            .assertValues(listOf("Test"))
+        categoryClient.searchCategoriesForPrefix("tes", 10, 10)
+            .test()
+            .assertValues(listOf("Test"))
     }
 
     @Test
     fun searchCategoriesForPrefixNull() {
-        val mwQueryResult = Mockito.mock(MwQueryResult::class.java)
-        Mockito.`when`(mwQueryResult.pages()).thenReturn(null)
-        val mockResponse = Mockito.mock(MwQueryResponse::class.java)
-        Mockito.`when`(mockResponse.query()).thenReturn(mwQueryResult)
-
-        Mockito.`when`(categoryInterface!!.searchCategoriesForPrefix(ArgumentMatchers.anyString(), ArgumentMatchers.anyInt(), ArgumentMatchers.anyInt()))
-                .thenReturn(Observable.just(mockResponse))
-        categoryClient!!.searchCategoriesForPrefix("tes", 10).subscribe(
-                { fail("SearchCategories returned element when it shouldn't have.") },
-                { s -> throw s })
-        categoryClient!!.searchCategoriesForPrefix("tes", 10, 10).subscribe(
-                { fail("SearchCategories returned element when it shouldn't have.") },
-                { s -> throw s })
+        val mockResponse = withNullPages()
+        whenever(categoryInterface.searchCategoriesForPrefix(anyString(), anyInt(), anyInt()))
+            .thenReturn(Observable.just(mockResponse))
+        categoryClient.searchCategoriesForPrefix("tes", 10)
+            .test()
+            .assertValues(emptyList())
+        categoryClient.searchCategoriesForPrefix("tes", 10, 10)
+            .test()
+            .assertValues(emptyList())
     }
 
     @Test
     fun getParentCategoryListFound() {
-        val mwQueryPage = Mockito.mock(MwQueryPage::class.java)
-        Mockito.`when`(mwQueryPage.title()).thenReturn("Category:Test")
-        val mwQueryResult = Mockito.mock(MwQueryResult::class.java)
-        Mockito.`when`(mwQueryResult.pages()).thenReturn(listOf(mwQueryPage))
-        val mockResponse = Mockito.mock(MwQueryResponse::class.java)
-        Mockito.`when`(mockResponse.query()).thenReturn(mwQueryResult)
-
-        Mockito.`when`(categoryInterface!!.getParentCategoryList(ArgumentMatchers.anyString()))
-                .thenReturn(Observable.just(mockResponse))
-
-        val actualCategoryName = categoryClient!!.getParentCategoryList("tes").blockingFirst()
-        assertEquals("Test", actualCategoryName)
+        val mockResponse = withMockResponse("Category:Test")
+        whenever(categoryInterface.getParentCategoryList(anyString()))
+            .thenReturn(Observable.just(mockResponse))
+        categoryClient.getParentCategoryList("tes")
+            .test()
+            .assertValues(listOf("Test"))
     }
 
     @Test
     fun getParentCategoryListNull() {
-        val mwQueryResult = Mockito.mock(MwQueryResult::class.java)
-        Mockito.`when`(mwQueryResult.pages()).thenReturn(null)
-        val mockResponse = Mockito.mock(MwQueryResponse::class.java)
-        Mockito.`when`(mockResponse.query()).thenReturn(mwQueryResult)
-
-        Mockito.`when`(categoryInterface!!.getParentCategoryList(ArgumentMatchers.anyString()))
-                .thenReturn(Observable.just(mockResponse))
-        categoryClient!!.getParentCategoryList("tes").subscribe(
-                { fail("SearchCategories returned element when it shouldn't have.") },
-                { s -> throw s })
+        val mockResponse = withNullPages()
+        whenever(categoryInterface.getParentCategoryList(anyString()))
+            .thenReturn(Observable.just(mockResponse))
+        categoryClient.getParentCategoryList("tes")
+            .test()
+            .assertValues(emptyList())
     }
+
     @Test
     fun getSubCategoryListFound() {
-        val mwQueryPage = Mockito.mock(MwQueryPage::class.java)
-        Mockito.`when`(mwQueryPage.title()).thenReturn("Category:Test")
-        val mwQueryResult = Mockito.mock(MwQueryResult::class.java)
-        Mockito.`when`(mwQueryResult.pages()).thenReturn(listOf(mwQueryPage))
-        val mockResponse = Mockito.mock(MwQueryResponse::class.java)
-        Mockito.`when`(mockResponse.query()).thenReturn(mwQueryResult)
-
-        Mockito.`when`(categoryInterface!!.getSubCategoryList(ArgumentMatchers.anyString()))
-                .thenReturn(Observable.just(mockResponse))
-
-        val actualCategoryName = categoryClient!!.getSubCategoryList("tes").blockingFirst()
-        assertEquals("Test", actualCategoryName)
+        val mockResponse = withMockResponse("Category:Test")
+        whenever(categoryInterface.getSubCategoryList("tes"))
+            .thenReturn(Observable.just(mockResponse))
+        categoryClient.getSubCategoryList("tes")
+            .test()
+            .assertValues(listOf("Test"))
     }
 
     @Test
     fun getSubCategoryListNull() {
-        val mwQueryResult = Mockito.mock(MwQueryResult::class.java)
-        Mockito.`when`(mwQueryResult.pages()).thenReturn(null)
-        val mockResponse = Mockito.mock(MwQueryResponse::class.java)
-        Mockito.`when`(mockResponse.query()).thenReturn(mwQueryResult)
-
-        Mockito.`when`(categoryInterface!!.getSubCategoryList(ArgumentMatchers.anyString()))
-                .thenReturn(Observable.just(mockResponse))
-        categoryClient!!.getSubCategoryList("tes").subscribe(
-                { fail("SearchCategories returned element when it shouldn't have.") },
-                { s -> throw s })
+        val mockResponse = withNullPages()
+        whenever(categoryInterface.getSubCategoryList(anyString()))
+            .thenReturn(Observable.just(mockResponse))
+        categoryClient.getSubCategoryList("tes")
+            .test()
+            .assertValues(emptyList())
     }
-}
+
+    private fun withMockResponse(title: String): MwQueryResponse? {
+        val mwQueryPage: MwQueryPage = mock()
+        whenever(mwQueryPage.title()).thenReturn(title)
+        val mwQueryResult: MwQueryResult = mock()
+        whenever(mwQueryResult.pages()).thenReturn(listOf(mwQueryPage))
+        val mockResponse = mock(MwQueryResponse::class.java)
+        whenever(mockResponse.query()).thenReturn(mwQueryResult)
+        return mockResponse
+    }
+
+    private fun withNullPages(): MwQueryResponse? {
+        val mwQueryResult = mock(MwQueryResult::class.java)
+        whenever(mwQueryResult.pages()).thenReturn(null)
+        val mockResponse = mock(MwQueryResponse::class.java)
+        whenever(mockResponse.query()).thenReturn(mwQueryResult)
+        return mockResponse
+    }
+}

app/src/test/kotlin/fr/free/nrw/commons/upload/CategoriesPresenterTest.kt

@@ -1,7 +1,7 @@
 package fr.free.nrw.commons.upload
 
-import com.nhaarman.mockitokotlin2.verify
-import com.nhaarman.mockitokotlin2.whenever
+import com.nhaarman.mockitokotlin2.*
+import fr.free.nrw.commons.R
 import fr.free.nrw.commons.category.CategoryItem
 import fr.free.nrw.commons.repository.UploadRepository
 import fr.free.nrw.commons.upload.categories.CategoriesContract
@@ -10,7 +10,6 @@ import io.reactivex.Observable
 import io.reactivex.schedulers.TestScheduler
 import org.junit.Before
 import org.junit.Test
-import org.mockito.ArgumentMatchers
 import org.mockito.Mock
 import org.mockito.MockitoAnnotations
 
@@ -20,6 +19,7 @@ import org.mockito.MockitoAnnotations
 class CategoriesPresenterTest {
     @Mock
     internal lateinit var repository: UploadRepository
+
     @Mock
     internal lateinit var view: CategoriesContract.View
 
@@ -49,30 +49,76 @@ class CategoriesPresenterTest {
      * unit test case for method CategoriesPresenter.searchForCategories
      */
     @Test
-    fun searchForCategoriesTest() {
-        whenever(repository.sortBySimilarity(ArgumentMatchers.anyString())).thenReturn(Comparator<CategoryItem> { _, _ -> 1 })
-        whenever(repository.selectedCategories).thenReturn(categoryItems)
-        whenever(repository.searchAll(ArgumentMatchers.anyString(), ArgumentMatchers.anyList())).thenReturn(Observable.empty())
+    fun `searchForCategories combines selection and search results without years distinctly`() {
+        val nonEmptyCaptionUploadItem = mock<UploadItem>()
+        whenever(nonEmptyCaptionUploadItem.uploadMediaDetails)
+            .thenReturn(listOf(UploadMediaDetail(captionText = "nonEmpty")))
+        val emptyCaptionUploadItem = mock<UploadItem>()
+        whenever(emptyCaptionUploadItem.uploadMediaDetails)
+            .thenReturn(listOf(UploadMediaDetail(captionText = "")))
+        whenever(repository.uploads).thenReturn(
+            listOf(
+                nonEmptyCaptionUploadItem,
+                emptyCaptionUploadItem
+            )
+        )
+        whenever(repository.searchAll("test", listOf("nonEmpty")))
+            .thenReturn(
+                Observable.just(
+                    listOf(
+                        categoryItem("selected"),
+                        categoryItem("doesContainYear")
+                    )
+                )
+            )
+        whenever(repository.containsYear("selected")).thenReturn(false)
+        whenever(repository.containsYear("doesContainYear")).thenReturn(true)
+        whenever(repository.selectedCategories).thenReturn(listOf(categoryItem("selected", true)))
         categoriesPresenter.searchForCategories("test")
+        testScheduler.triggerActions()
         verify(view).showProgress(true)
         verify(view).showError(null)
         verify(view).setCategories(null)
-        testScheduler.triggerActions()
-        verify(view).setCategories(categoryItems)
+        verify(view).setCategories(listOf(categoryItem("selected", true)))
         verify(view).showProgress(false)
+        verifyNoMoreInteractions(view)
+    }
+
+    @Test
+    fun `searchForCategoriesTest sets Error when list is empty`() {
+        whenever(repository.uploads).thenReturn(listOf())
+        whenever(repository.searchAll(any(), any())).thenReturn(Observable.just(listOf()))
+        whenever(repository.selectedCategories).thenReturn(listOf())
+        categoriesPresenter.searchForCategories("test")
+        testScheduler.triggerActions()
+        verify(view).showProgress(true)
+        verify(view).showError(null)
+        verify(view).setCategories(null)
+        verify(view).setCategories(listOf())
+        verify(view).showProgress(false)
+        verify(view).showError(R.string.no_categories_found)
+        verifyNoMoreInteractions(view)
     }
 
     /**
      * unit test for method CategoriesPresenter.verifyCategories
      */
     @Test
-    fun verifyCategoriesTest() {
-        whenever(repository.selectedCategories).thenReturn(categoryItems)
+    fun `verifyCategories with non empty selection goes to next screen`() {
+        val item = categoryItem()
+        whenever(repository.selectedCategories).thenReturn(listOf(item))
         categoriesPresenter.verifyCategories()
-        verify(repository).setSelectedCategories(ArgumentMatchers.anyList())
+        verify(repository).setSelectedCategories(listOf(item.name))
         verify(view).goToNextScreen()
     }
 
+    @Test
+    fun `verifyCategories with empty selection show no category selected`() {
+        whenever(repository.selectedCategories).thenReturn(listOf())
+        categoriesPresenter.verifyCategories()
+        verify(view).showNoCategorySelected()
+    }
+
     /**
      * Test onCategory Item clicked
      */
@@ -81,4 +127,7 @@ class CategoriesPresenterTest {
         categoriesPresenter.onCategoryItemClicked(categoryItem)
         verify(repository).onCategoryClicked(categoryItem)
     }
+
+    private fun categoryItem(name: String = "name", selected: Boolean = false) =
+        CategoryItem(name, selected)
 }

app/src/test/kotlin/fr/free/nrw/commons/upload/GpsCategoryModelTest.kt

@@ -1,76 +1,33 @@
 package fr.free.nrw.commons.upload
 
-import org.junit.Assert.*
 import org.junit.Before
 import org.junit.Test
 
 class GpsCategoryModelTest {
-
-    private lateinit var testObject: GpsCategoryModel
+    lateinit var gpsCategoryModel: GpsCategoryModel
 
     @Before
     fun setUp() {
-        testObject = GpsCategoryModel()
+        gpsCategoryModel = GpsCategoryModel()
     }
 
     @Test
-    fun initiallyTheModelIsEmpty() {
-        assertFalse(testObject.gpsCatExists)
-        assertTrue(testObject.categoryList.isEmpty())
+    fun `intial value is empty`() {
+        gpsCategoryModel.categoriesFromLocation.test().assertValues(emptyList())
     }
 
     @Test
-    fun addingCategoriesToTheModel() {
-        testObject.categoryList = listOf("one")
-        assertTrue(testObject.gpsCatExists)
-        assertFalse(testObject.categoryList.isEmpty())
-        assertEquals(listOf("one"), testObject.categoryList)
+    fun `setCategoriesFromLocation emits the new value`() {
+        val expectedList = listOf("category")
+        gpsCategoryModel.categoriesFromLocation.test()
+            .also { gpsCategoryModel.setCategoriesFromLocation(expectedList) }
+            .assertValues(emptyList(), expectedList)
     }
 
     @Test
-    fun duplicatesAreIgnored() {
-        testObject.categoryList = listOf("one", "one")
-        assertEquals(listOf("one"), testObject.categoryList)
-    }
-
-    @Test
-    fun modelProtectsAgainstExternalModification() {
-        testObject.categoryList = listOf("one")
-
-        val list = testObject.categoryList
-        list.add("two")
-
-        assertEquals(listOf("one"), testObject.categoryList)
-    }
-
-    @Test
-    fun clearingTheModel() {
-        testObject.categoryList = listOf("one")
-
-        testObject.clear()
-        assertFalse(testObject.gpsCatExists)
-        assertTrue(testObject.categoryList.isEmpty())
-
-        testObject.categoryList = listOf("two")
-        assertEquals(listOf("two"), testObject.categoryList)
-    }
-
-    @Test
-    fun settingTheListHandlesNull() {
-        testObject.categoryList = listOf("one")
-
-        testObject.categoryList = null
-
-        assertFalse(testObject.gpsCatExists)
-        assertTrue(testObject.categoryList.isEmpty())
-    }
-
-    @Test
-    fun settingTheListOverwritesExistingValues() {
-        testObject.categoryList = listOf("one")
-
-        testObject.categoryList = listOf("two")
-
-        assertEquals(listOf("two"), testObject.categoryList)
+    fun `clear emits an empty value`() {
+        gpsCategoryModel.categoriesFromLocation.test()
+            .also { gpsCategoryModel.clear() }
+            .assertValues(emptyList(), emptyList())
     }
 }