Upload tests (#2086)

* Add unit tests for upload flows

* Tests for upload model

* Test fixes

* Remove empty test cases

* Changes based on comments

app/src/test/kotlin/fr/free/nrw/commons/TestCommonsApplication.kt

@@ -24,7 +24,8 @@ class TestCommonsApplication : CommonsApplication() {
     override fun onCreate() {
         if (mockApplicationComponent == null) {
             mockApplicationComponent = DaggerCommonsApplicationComponent.builder()
-                    .appModule(MockCommonsApplicationModule(this)).build()
+                    .appModule(MockCommonsApplicationModule(this))
+                    .build()
         }
         super.onCreate()
     }

app/src/test/kotlin/fr/free/nrw/commons/mwapi/ApacheHttpClientMediaWikiApiTest.kt

@@ -1,6 +1,7 @@
 package fr.free.nrw.commons.mwapi
 
 import android.content.SharedPreferences
+import android.net.Uri
 import android.os.Build
 import android.preference.PreferenceManager
 import com.google.gson.Gson
@@ -15,9 +16,12 @@ import org.junit.Assert.*
 import org.junit.Before
 import org.junit.Test
 import org.junit.runner.RunWith
+import org.mockito.Mockito.mock
 import org.robolectric.RobolectricTestRunner
 import org.robolectric.RuntimeEnvironment
 import org.robolectric.annotation.Config
+import timber.log.Timber
+import java.io.InputStream
 import java.net.URLDecoder
 import java.text.SimpleDateFormat
 import java.util.*

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

@@ -0,0 +1,41 @@
+package fr.free.nrw.commons.upload
+
+import android.content.ContentResolver
+import android.content.SharedPreferences
+import fr.free.nrw.commons.caching.CacheController
+import fr.free.nrw.commons.mwapi.CategoryApi
+import org.junit.Before
+import org.junit.Test
+import org.mockito.InjectMocks
+import org.mockito.Mock
+import org.mockito.Mockito.anyString
+import org.mockito.Mockito.mock
+import org.mockito.MockitoAnnotations
+import javax.inject.Inject
+import javax.inject.Named
+
+class FileProcessorTest {
+
+    @Mock
+    internal var cacheController: CacheController? = null
+    @Mock
+    internal var gpsCategoryModel: GpsCategoryModel? = null
+    @Mock
+    internal var apiCall: CategoryApi? = null
+    @Mock
+    @field:[Inject Named("default_preferences")]
+    internal var prefs: SharedPreferences? = null
+
+    @InjectMocks
+    var fileProcessor: FileProcessor? = null
+
+    @Before
+    fun setup() {
+        MockitoAnnotations.initMocks(this)
+    }
+
+    @Test
+    fun processFileCoordinates() {
+
+    }
+}

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

@@ -0,0 +1,53 @@
+package fr.free.nrw.commons.upload
+
+import android.content.ComponentName
+import android.content.Context
+import android.content.SharedPreferences
+import fr.free.nrw.commons.HandlerService
+import fr.free.nrw.commons.auth.SessionManager
+import fr.free.nrw.commons.contributions.Contribution
+import org.junit.Before
+import org.junit.Test
+import org.mockito.InjectMocks
+import org.mockito.Mock
+import org.mockito.Mockito.`when`
+import org.mockito.Mockito.mock
+import org.mockito.MockitoAnnotations
+
+class UploadControllerTest {
+
+    @Mock
+    internal var sessionManager: SessionManager? = null
+    @Mock
+    internal var context: Context? = null
+    @Mock
+    internal var prefs: SharedPreferences? = null
+
+    @InjectMocks
+    var uploadController: UploadController? = null
+
+    @Before
+    fun setup() {
+        MockitoAnnotations.initMocks(this)
+        val uploadService = mock(UploadService::class.java)
+        val binder = mock(HandlerService.HandlerServiceLocalBinder::class.java)
+        `when`(binder.service).thenReturn(uploadService)
+        uploadController!!.uploadServiceConnection.onServiceConnected(mock(ComponentName::class.java), binder)
+    }
+
+    @Test
+    fun prepareService() {
+        uploadController!!.prepareService()
+    }
+
+    @Test
+    fun cleanup() {
+        uploadController!!.cleanup()
+    }
+
+    @Test
+    fun startUpload() {
+        val contribution = mock(Contribution::class.java)
+        uploadController!!.startUpload(contribution)
+    }
+}

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

@@ -0,0 +1,267 @@
+package fr.free.nrw.commons.upload
+
+import android.app.Application
+import android.content.ContentResolver
+import android.content.Context
+import android.content.SharedPreferences
+import android.net.Uri
+import fr.free.nrw.commons.auth.SessionManager
+import fr.free.nrw.commons.mwapi.MediaWikiApi
+import org.junit.After
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Test
+import org.mockito.ArgumentMatchers.any
+import org.mockito.ArgumentMatchers.anyString
+import org.mockito.InjectMocks
+import org.mockito.Mock
+import org.mockito.Mockito.`when`
+import org.mockito.Mockito.mock
+import org.mockito.MockitoAnnotations
+import java.io.FileInputStream
+import java.io.InputStream
+import javax.inject.Inject
+import javax.inject.Named
+
+
+class UploadModelTest {
+
+    @Mock
+    @field:[Inject Named("licenses")]
+    internal var licenses: List<String>? = null
+    @Mock
+    @field:[Inject Named("default_preferences")]
+    internal var prefs: SharedPreferences? = null
+    @Mock
+    @field:[Inject Named("licenses_by_name")]
+    internal var licensesByName: Map<String, String>? = null
+    @Mock
+    internal var context: Context? = null
+    @Mock
+    internal var mwApi: MediaWikiApi? = null
+    @Mock
+    internal var sessionManage: SessionManager? = null
+    @Mock
+    internal var fileUtilsWrapper: FileUtilsWrapper? = null
+    @Mock
+    internal var fileProcessor: FileProcessor? = null
+
+    @InjectMocks
+    var uploadModel: UploadModel? = null
+
+    @Before
+    @Throws(Exception::class)
+    fun setUp() {
+        MockitoAnnotations.initMocks(this)
+
+        `when`(context!!.applicationContext)
+                .thenReturn(mock(Application::class.java))
+        `when`(fileUtilsWrapper!!.createCopyPathAndCopy(any(Uri::class.java), any(Context::class.java)))
+                .thenReturn("file.jpg")
+        `when`(fileUtilsWrapper!!.createExternalCopyPathAndCopy(any(Uri::class.java), any(ContentResolver::class.java)))
+                .thenReturn("extFile.jpg")
+        `when`(fileUtilsWrapper!!.getFileExt(anyString()))
+                .thenReturn("jpg")
+        `when`(fileUtilsWrapper!!.getSHA1(any(InputStream::class.java)))
+                .thenReturn("sha")
+        `when`(fileUtilsWrapper!!.getFileInputStream(anyString()))
+                .thenReturn(mock(FileInputStream::class.java))
+
+    }
+
+    @After
+    @Throws(Exception::class)
+    fun tearDown() {
+    }
+
+    @Test
+    fun receive() {
+        val element = mock(Uri::class.java)
+        val element2 = mock(Uri::class.java)
+        var uriList: List<Uri> = mutableListOf<Uri>(element, element2)
+        uploadModel!!.receive(uriList, "image/jpeg", "external") { _, _ -> }
+        assertTrue(uploadModel!!.items.size == 2)
+    }
+
+    @Test
+    fun receiveDirect() {
+        val element = mock(Uri::class.java)
+        uploadModel!!.receiveDirect(element, "image/jpeg", "external", "Q1", "Test", "Test"
+        ) { _, _ -> }
+        assertTrue(uploadModel!!.items.size == 1)
+    }
+
+    @Test
+    fun verifyPreviousNotAvailableForDirectUpload() {
+        val element = mock(Uri::class.java)
+        uploadModel!!.receiveDirect(element, "image/jpeg", "external", "Q1", "Test", "Test"
+        ) { _, _ -> }
+        assertFalse(uploadModel!!.isPreviousAvailable)
+    }
+
+    @Test
+    fun verifyNextAvailableForDirectUpload() {
+        val element = mock(Uri::class.java)
+        uploadModel!!.receiveDirect(element, "image/jpeg", "external", "Q1", "Test", "Test"
+        ) { _, _ -> }
+        assertTrue(uploadModel!!.isNextAvailable)
+    }
+
+    @Test
+    fun verifyPreviousNotAvailable() {
+        val element = mock(Uri::class.java)
+        val element2 = mock(Uri::class.java)
+        var uriList: List<Uri> = mutableListOf<Uri>(element, element2)
+        uploadModel!!.receive(uriList, "image/jpeg", "external") { _, _ -> }
+        assertFalse(uploadModel!!.isPreviousAvailable)
+    }
+
+    @Test
+    fun verifyNextAvailable() {
+        val element = mock(Uri::class.java)
+        val element2 = mock(Uri::class.java)
+        var uriList: List<Uri> = mutableListOf<Uri>(element, element2)
+        uploadModel!!.receive(uriList, "image/jpeg", "external") { _, _ -> }
+        assertTrue(uploadModel!!.isNextAvailable)
+    }
+
+    @Test
+    fun isSubmitAvailable() {
+        val element = mock(Uri::class.java)
+        val element2 = mock(Uri::class.java)
+        var uriList: List<Uri> = mutableListOf<Uri>(element, element2)
+        uploadModel!!.receive(uriList, "image/jpeg", "external") { _, _ -> }
+        assertTrue(uploadModel!!.isNextAvailable)
+    }
+
+    @Test
+    fun isSubmitAvailableForDirectUpload() {
+        val element = mock(Uri::class.java)
+        uploadModel!!.receiveDirect(element, "image/jpeg", "external", "Q1", "Test", "Test"
+        ) { _, _ -> }
+        assertTrue(uploadModel!!.isNextAvailable)
+    }
+
+    @Test
+    fun getCurrentStepForDirectUpload() {
+        val element = mock(Uri::class.java)
+        uploadModel!!.receiveDirect(element, "image/jpeg", "external", "Q1", "Test", "Test"
+        ) { _, _ -> }
+        assertTrue(uploadModel!!.currentStep == 1)
+    }
+
+    @Test
+    fun getCurrentStep() {
+        val element = mock(Uri::class.java)
+        val element2 = mock(Uri::class.java)
+        var uriList: List<Uri> = mutableListOf<Uri>(element, element2)
+        uploadModel!!.receive(uriList, "image/jpeg", "external") { _, _ -> }
+        assertTrue(uploadModel!!.currentStep == 1)
+    }
+
+    @Test
+    fun getStepCount() {
+        val element = mock(Uri::class.java)
+        val element2 = mock(Uri::class.java)
+        var uriList: List<Uri> = mutableListOf<Uri>(element, element2)
+        uploadModel!!.receive(uriList, "image/jpeg", "external") { _, _ -> }
+        assertTrue(uploadModel!!.stepCount == 4)
+    }
+
+    @Test
+    fun getStepCountForDirectUpload() {
+        val element = mock(Uri::class.java)
+        uploadModel!!.receiveDirect(element, "image/jpeg", "external", "Q1", "Test", "Test"
+        ) { _, _ -> }
+        assertTrue(uploadModel!!.stepCount == 3)
+    }
+
+    @Test
+    fun getDirectCount() {
+        val element = mock(Uri::class.java)
+        uploadModel!!.receiveDirect(element, "image/jpeg", "external", "Q1", "Test", "Test"
+        ) { _, _ -> }
+        assertTrue(uploadModel!!.count == 1)
+    }
+
+    @Test
+    fun getCount() {
+        val element = mock(Uri::class.java)
+        val element2 = mock(Uri::class.java)
+        var uriList: List<Uri> = mutableListOf<Uri>(element, element2)
+        uploadModel!!.receive(uriList, "image/jpeg", "external") { _, _ -> }
+        assertTrue(uploadModel!!.count == 2)
+    }
+
+    @Test
+    fun getUploads() {
+        val element = mock(Uri::class.java)
+        val element2 = mock(Uri::class.java)
+        var uriList: List<Uri> = mutableListOf<Uri>(element, element2)
+        uploadModel!!.receive(uriList, "image/jpeg", "external") { _, _ -> }
+        assertTrue(uploadModel!!.uploads.size == 2)
+    }
+
+    @Test
+    fun getDirectUploads() {
+        val element = mock(Uri::class.java)
+        uploadModel!!.receiveDirect(element, "image/jpeg", "external", "Q1", "Test", "Test"
+        ) { _, _ -> }
+        assertTrue(uploadModel!!.uploads.size == 1)
+    }
+
+    @Test
+    fun isTopCardState() {
+        val element = mock(Uri::class.java)
+        val element2 = mock(Uri::class.java)
+        var uriList: List<Uri> = mutableListOf<Uri>(element, element2)
+        uploadModel!!.receive(uriList, "image/jpeg", "external") { _, _ -> }
+        assertTrue(uploadModel!!.isTopCardState)
+    }
+
+    @Test
+    fun isTopCardStateForDirectUpload() {
+        val element = mock(Uri::class.java)
+        uploadModel!!.receiveDirect(element, "image/jpeg", "external", "Q1", "Test", "Test"
+        ) { _, _ -> }
+        assertTrue(uploadModel!!.isTopCardState)
+    }
+
+    @Test
+    fun next() {
+        val element = mock(Uri::class.java)
+        val element2 = mock(Uri::class.java)
+        var uriList: List<Uri> = mutableListOf<Uri>(element, element2)
+        uploadModel!!.receive(uriList, "image/jpeg", "external") { _, _ -> }
+        assertTrue(uploadModel!!.currentStep == 1)
+        uploadModel!!.next()
+        assertTrue(uploadModel!!.currentStep == 2)
+    }
+
+    @Test
+    fun previous() {
+        val element = mock(Uri::class.java)
+        val element2 = mock(Uri::class.java)
+        var uriList: List<Uri> = mutableListOf<Uri>(element, element2)
+        uploadModel!!.receive(uriList, "image/jpeg", "external") { _, _ -> }
+        assertTrue(uploadModel!!.currentStep == 1)
+        uploadModel!!.next()
+        assertTrue(uploadModel!!.currentStep == 2)
+        uploadModel!!.previous()
+        assertTrue(uploadModel!!.currentStep == 1)
+    }
+
+    @Test
+    fun isShowingItem() {
+        val element = mock(Uri::class.java)
+        val element2 = mock(Uri::class.java)
+        var uriList: List<Uri> = mutableListOf<Uri>(element, element2)
+        uploadModel!!.receive(uriList, "image/jpeg", "external") { _, _ -> }
+        assertTrue(uploadModel!!.isShowingItem)
+    }
+
+    @Test
+    fun buildContributions() {
+    }
+}

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

@@ -0,0 +1,50 @@
+package fr.free.nrw.commons.upload
+
+import android.net.Uri
+import fr.free.nrw.commons.mwapi.MediaWikiApi
+import org.junit.Before
+import org.junit.Test
+import org.mockito.InjectMocks
+import org.mockito.Mock
+import org.mockito.Mockito
+import org.mockito.MockitoAnnotations
+
+class UploadPresenterTest {
+
+    @Mock
+    internal var uploadModel: UploadModel? = null
+    @Mock
+    internal var uploadController: UploadController? = null
+    @Mock
+    internal var mediaWikiApi: MediaWikiApi? = null
+
+    @InjectMocks
+    var uploadPresenter: UploadPresenter? = null
+
+    @Before
+    @Throws(Exception::class)
+    fun setUp() {
+        MockitoAnnotations.initMocks(this)
+    }
+
+    @Test
+    fun receiveMultipleItems() {
+        val element = Mockito.mock(Uri::class.java)
+        val element2 = Mockito.mock(Uri::class.java)
+        var uriList: List<Uri> = mutableListOf<Uri>(element, element2)
+        uploadPresenter!!.receive(uriList, "image/jpeg", "external")
+    }
+
+    @Test
+    fun receiveSingleItem() {
+        val element = Mockito.mock(Uri::class.java)
+        uploadPresenter!!.receive(element, "image/jpeg", "external")
+    }
+
+    @Test
+    fun receiveDirect() {
+        val element = Mockito.mock(Uri::class.java)
+        uploadModel!!.receiveDirect(element, "image/jpeg", "external", "Q1", "Test", "Test"
+        ) { _, _ -> }
+    }
+}