fix: fixed isBarcodeValid method in ProductUtilsTest.kt

ref: use mockito kotlin when possible

app/src/main/java/openfoodfacts/github/scrachx/openfood/utils/Utils.kt

@@ -240,17 +240,19 @@ fun <T : View?> ViewGroup.getViewsByType(typeClass: Class<T>): List<T> {
 /**
  * @param barcode
  * @return true if valid according to [EAN13CheckDigit.EAN13_CHECK_DIGIT]
- * and if the barcode doesn't start will 977/978/979 (Book barcode)
+ * and if the barcode doesn't start with 977/978/979 (Book barcode)
  */
 fun isBarcodeValid(barcode: String?): Boolean {
-    // For debug only: the barcode '1' is used for test:
-    if (ApiFields.Defaults.DEBUG_BARCODE == barcode) return true
-    return barcode != null
-            && EAN13CheckDigit.EAN13_CHECK_DIGIT.isValid(barcode)
-            && barcode.length > 3
-            && (!barcode.substring(0, 3).contains("977")
-            || !barcode.substring(0, 3).contains("978")
-            || !barcode.substring(0, 3).contains("979"))
+    // DEBUG ONLY: the barcode '1' is used for test:
+    if (barcode == ApiFields.Defaults.DEBUG_BARCODE) return true
+
+    if (
+        barcode == null || barcode.length <= 3
+        || !EAN13CheckDigit.EAN13_CHECK_DIGIT.isValid(barcode)
+    ) return false
+
+    // It must not start with these prefixes
+    return barcode.take(3) !in listOf("977", "978", "979")
 }
 
 /**

app/src/test/java/openfoodfacts/github/scrachx/openfood/category/CategoryRepositoryTest.kt

@@ -1,6 +1,6 @@
 package openfoodfacts.github.scrachx.openfood.category
 
-import com.google.common.truth.Truth
+import com.google.common.truth.Truth.assertThat
 import io.reactivex.Single
 import io.reactivex.observers.TestObserver
 import openfoodfacts.github.scrachx.openfood.MockitoHelper
@@ -12,9 +12,9 @@ import org.junit.Before
 import org.junit.Test
 import org.junit.runner.RunWith
 import org.mockito.Mock
-import org.mockito.Mockito
 import org.mockito.junit.MockitoJUnitRunner
-import org.mockito.Mockito.`when` as mockitoWhen
+import org.mockito.kotlin.doReturn
+import org.mockito.kotlin.whenever
 
 /**
  * Created by Abdelali Eramli on 01/01/2018.
@@ -36,20 +36,19 @@ class CategoryRepositoryTest {
 
     @Before
     fun setup() {
-        mockitoWhen(mapper.fromNetwork(MockitoHelper.anyObject())).thenReturn(listOf(category, category, category))
-        mockitoWhen(networkService.getCategories()).thenReturn(Single.just(response))
+        whenever(mapper.fromNetwork(MockitoHelper.anyObject())) doReturn listOf(category, category, category)
+        whenever(networkService.getCategories()) doReturn Single.just(response)
         repository = CategoryRepository(networkService, mapper)
     }
 
-    private fun <T> any(type: Class<T>): T = Mockito.any(type)
-
     @Test
     fun retrieveAll_Success() {
         val testObserver = TestObserver<List<Category>>()
         repository.retrieveAll().subscribe(testObserver)
         testObserver.awaitTerminalEvent()
+
         val result = testObserver.values()[0]
-        Truth.assertThat(result[0]).isEqualTo(category)
+        assertThat(result[0]).isEqualTo(category)
     }
 
 }

app/src/test/java/openfoodfacts/github/scrachx/openfood/models/ModifierTest.kt

@@ -5,6 +5,9 @@ import com.google.common.truth.Truth.assertThat
 import openfoodfacts.github.scrachx.openfood.utils.modifier
 import org.junit.Test
 import org.mockito.Mockito
+import org.mockito.kotlin.doReturn
+import org.mockito.kotlin.mock
+import org.mockito.kotlin.whenever
 
 class ModifierTest {
     @Test
@@ -29,14 +32,14 @@ class ModifierTest {
 
     @Test
     fun `modifier should match index`() {
-        val mockSpinner = Mockito.mock(Spinner::class.java)
-        Mockito.`when`(mockSpinner.selectedItemPosition).thenReturn(0)
+        val mockSpinner = mock<Spinner>()
+        whenever(mockSpinner.selectedItemPosition) doReturn 0
         assertThat(mockSpinner.modifier).isEqualTo(Modifier.EQUALS_TO)
 
-        Mockito.`when`(mockSpinner.selectedItemPosition).thenReturn(1)
+        whenever(mockSpinner.selectedItemPosition) doReturn 1
         assertThat(mockSpinner.modifier).isEqualTo(Modifier.LESS_THAN)
 
-        Mockito.`when`(mockSpinner.selectedItemPosition).thenReturn(2)
+        whenever(mockSpinner.selectedItemPosition) doReturn 2
         assertThat(mockSpinner.modifier).isEqualTo(Modifier.GREATER_THAN)
     }
 }

app/src/test/java/openfoodfacts/github/scrachx/openfood/models/NutrimentTest.kt

@@ -7,7 +7,7 @@ import org.junit.Test
 class NutrimentTest {
 
     @Test
-    fun `test findbyKey`() {
+    fun `test findByKey`() {
         Nutriment.values().forEach {
             assertThat(Nutriment.findbyKey(it.key)).isEqualTo(it)
         }

app/src/test/java/openfoodfacts/github/scrachx/openfood/models/entities/additive/AdditiveTest.kt

@@ -9,9 +9,10 @@ import org.junit.Test
 import org.junit.runner.RunWith
 import org.mockito.ArgumentMatchers
 import org.mockito.Mock
-import org.mockito.Mockito
+import org.mockito.Mockito.verify
 import org.mockito.junit.MockitoJUnitRunner
-import org.mockito.Mockito.`when` as mockitoWhen
+import org.mockito.kotlin.doReturn
+import org.mockito.kotlin.whenever
 
 /**
  * Tests for [Additive]
@@ -30,10 +31,9 @@ class AdditiveTest {
 
     @Before
     fun setup() {
-        mockitoWhen(mockDaoSession!!.additiveNameDao).thenReturn(mockAdditiveNameDao)
-        mockitoWhen(mockDaoSession.additiveDao).thenReturn(mockAdditiveDao)
-        mockitoWhen(mockAdditiveNameDao._queryAdditive_Names(ArgumentMatchers.any()))
-                .thenReturn(listOf(ADDITIVE_NAME_1, ADDITIVE_NAME_2))
+        whenever(mockDaoSession!!.additiveNameDao) doReturn mockAdditiveNameDao
+        whenever(mockDaoSession.additiveDao) doReturn mockAdditiveDao
+        whenever(mockAdditiveNameDao._queryAdditive_Names(ArgumentMatchers.any())) doReturn listOf(ADDITIVE_NAME_1, ADDITIVE_NAME_2)
         mAdditive = Additive()
     }
 
@@ -60,7 +60,7 @@ class AdditiveTest {
     fun deleteWithNonNullDao_callsDeleteOnDao() {
         mAdditive.__setDaoSession(mockDaoSession)
         mAdditive.delete()
-        Mockito.verify(mockAdditiveDao).delete(mAdditive)
+        verify(mockAdditiveDao).delete(mAdditive)
     }
 
     @Test
@@ -72,7 +72,7 @@ class AdditiveTest {
     fun refreshWithNonNullDao_callsRefreshOnDao() {
         mAdditive.__setDaoSession(mockDaoSession)
         mAdditive.refresh()
-        Mockito.verify(mockAdditiveDao)?.refresh(mAdditive)
+        verify(mockAdditiveDao).refresh(mAdditive)
     }
 
     @Test
@@ -84,7 +84,7 @@ class AdditiveTest {
     fun updateWithNonNullDao_callsUpdateOnDao() {
         mAdditive.__setDaoSession(mockDaoSession)
         mAdditive.update()
-        Mockito.verify(mockAdditiveDao)?.update(mAdditive)
+        verify(mockAdditiveDao).update(mAdditive)
     }
 
     companion object {

app/src/test/java/openfoodfacts/github/scrachx/openfood/models/entities/analysistag/AnalysisTagTest.kt

@@ -9,18 +9,19 @@ import openfoodfacts.github.scrachx.openfood.models.entities.allergen.PEANUTS_EN
 import openfoodfacts.github.scrachx.openfood.models.entities.allergen.UNIQUE_ALLERGEN_ID_1
 import openfoodfacts.github.scrachx.openfood.models.entities.allergen.UNIQUE_ALLERGEN_ID_2
 import org.greenrobot.greendao.DaoException
-import org.junit.Assert
+import org.junit.Assert.assertThrows
 import org.junit.Before
 import org.junit.Test
 import org.junit.runner.RunWith
 import org.mockito.Mock
 import org.mockito.Mockito
 import org.mockito.junit.MockitoJUnitRunner
-import org.mockito.Mockito.`when` as mockitoWhen
+import org.mockito.kotlin.doReturn
+import org.mockito.kotlin.whenever
 
 @RunWith(MockitoJUnitRunner::class)
 class AnalysisTagTest {
-    private var testAnalysisTag: AnalysisTag? = null
+    private lateinit var testAnalysisTag: AnalysisTag
     private val tagEnglish = AnalysisTagName(UNIQUE_ALLERGEN_ID_2, LANGUAGE_CODE_ENGLISH, PEANUTS_EN, "show")
     private val tagGerman = AnalysisTagName(UNIQUE_ALLERGEN_ID_1, LANGUAGE_CODE_GERMAN, PEANUTS_DE, "show")
     private lateinit var tagNames: MutableList<AnalysisTagName>
@@ -34,20 +35,22 @@ class AnalysisTagTest {
     @Before
     fun setUp() {
         tagNames = arrayListOf(tagGerman, tagEnglish)
-        mockitoWhen(mockDaoSession!!.analysisTagNameDao).thenReturn(mockAnalysisTagNameDao)
-        mockitoWhen(mockAnalysisTagNameDao!!._queryAnalysisTag_Names(Mockito.any())).thenReturn(tagNames)
+
+        whenever(mockDaoSession!!.analysisTagNameDao) doReturn mockAnalysisTagNameDao
+        whenever(mockAnalysisTagNameDao!!._queryAnalysisTag_Names(Mockito.any())) doReturn tagNames
+
         testAnalysisTag = AnalysisTag()
     }
 
     @Test
     fun getNames_DaoSessionIsNull() {
-        Assert.assertThrows(DaoException::class.java) { testAnalysisTag!!.names }
+        assertThrows(DaoException::class.java) { testAnalysisTag.names }
     }
 
     @Test
     fun getNames_returnsListOfTags() {
-        testAnalysisTag!!.__setDaoSession(mockDaoSession)
-        val tags = testAnalysisTag!!.names
+        testAnalysisTag.__setDaoSession(mockDaoSession)
+        val tags = testAnalysisTag.names
         assertThat(tags[0].analysisTag).isEqualTo(UNIQUE_ALLERGEN_ID_1)
         assertThat(tags[0].languageCode).isEqualTo(LANGUAGE_CODE_GERMAN)
         assertThat(tags[0].name).isEqualTo(PEANUTS_DE)
@@ -59,7 +62,7 @@ class AnalysisTagTest {
     @Test(expected = DaoException::class)
     @Throws(DaoException::class)
     fun delete_throwsExceptionMyDaoIsNull() {
-        testAnalysisTag!!.__setDaoSession(mockDaoSession)
-        testAnalysisTag!!.delete()
+        testAnalysisTag.__setDaoSession(mockDaoSession)
+        testAnalysisTag.delete()
     }
 }

app/src/test/java/openfoodfacts/github/scrachx/openfood/models/entities/category/CategoryTest.kt

@@ -1,39 +1,39 @@
 package openfoodfacts.github.scrachx.openfood.models.entities.category
 
-import com.google.common.truth.Truth
+import com.google.common.truth.Truth.assertThat
 import openfoodfacts.github.scrachx.openfood.models.DaoSession
 import org.greenrobot.greendao.DaoException
 import org.junit.Assert.assertThrows
 import org.junit.Before
 import org.junit.Test
 import org.junit.runner.RunWith
-import org.mockito.ArgumentMatchers
 import org.mockito.Mock
-import org.mockito.Mockito
 import org.mockito.junit.MockitoJUnitRunner
-import org.mockito.Mockito.`when` as mockitoWhen
+import org.mockito.kotlin.any
+import org.mockito.kotlin.doReturn
+import org.mockito.kotlin.verify
+import org.mockito.kotlin.whenever
 
 /**
  * Tests for [Category]
  */
 @RunWith(MockitoJUnitRunner::class)
 class CategoryTest {
     @Mock
-    private val mockDaoSession: DaoSession? = null
+    private lateinit var mockDaoSession: DaoSession
 
     @Mock
-    private val mockCategoryDao: CategoryDao? = null
+    private lateinit var mockCategoryDao: CategoryDao
 
     @Mock
-    private val mockCategoryNameDao: CategoryNameDao? = null
+    private lateinit var mockCategoryNameDao: CategoryNameDao
     private lateinit var mCategory: Category
 
     @Before
     fun setup() {
-        mockitoWhen(mockDaoSession!!.categoryDao).thenReturn(mockCategoryDao)
-        mockitoWhen(mockDaoSession.categoryNameDao).thenReturn(mockCategoryNameDao)
-        mockitoWhen(mockCategoryNameDao!!._queryCategory_Names(ArgumentMatchers.any()))
-                .thenReturn(listOf(CATEGORY_NAME_1, CATEGORY_NAME_2))
+        whenever(mockDaoSession.categoryDao) doReturn mockCategoryDao
+        whenever(mockDaoSession.categoryNameDao) doReturn mockCategoryNameDao
+        whenever(mockCategoryNameDao._queryCategory_Names(any())) doReturn listOf(CATEGORY_NAME_1, CATEGORY_NAME_2)
         mCategory = Category()
     }
 
@@ -46,13 +46,13 @@ class CategoryTest {
     fun getNamesWithNullNamesAndNonNullDaoSession_setsNamesFromCategoryNameDao() {
         mCategory.__setDaoSession(mockDaoSession)
         val names = mCategory.names
-        Truth.assertThat(names).hasSize(2)
-        Truth.assertThat(names[0]!!.categoryTag).isEqualTo(CATEGORY_TAG_1)
-        Truth.assertThat(names[0]!!.languageCode).isEqualTo(LANGUAGE_CODE_ENGLISH)
-        Truth.assertThat(names[0]!!.name).isEqualTo(CATEGORY_NAME_NAME_1)
-        Truth.assertThat(names[1]!!.categoryTag).isEqualTo(CATEGORY_TAG_2)
-        Truth.assertThat(names[1]!!.languageCode).isEqualTo(LANGUAGE_CODE_FRENCH)
-        Truth.assertThat(names[1]!!.name).isEqualTo(CATEGORY_NAME_NAME_2)
+        assertThat(names).hasSize(2)
+        assertThat(names[0]!!.categoryTag).isEqualTo(CATEGORY_TAG_1)
+        assertThat(names[0]!!.languageCode).isEqualTo(LANGUAGE_CODE_ENGLISH)
+        assertThat(names[0]!!.name).isEqualTo(CATEGORY_NAME_NAME_1)
+        assertThat(names[1]!!.categoryTag).isEqualTo(CATEGORY_TAG_2)
+        assertThat(names[1]!!.languageCode).isEqualTo(LANGUAGE_CODE_FRENCH)
+        assertThat(names[1]!!.name).isEqualTo(CATEGORY_NAME_NAME_2)
     }
 
     @Test
@@ -64,7 +64,7 @@ class CategoryTest {
     fun deleteWithNonNullDao_callsDeleteOnDao() {
         mCategory.__setDaoSession(mockDaoSession)
         mCategory.delete()
-        Mockito.verify(mockCategoryDao)!!.delete(mCategory)
+        verify(mockCategoryDao).delete(mCategory)
     }
 
     @Test
@@ -76,7 +76,7 @@ class CategoryTest {
     fun refreshWithNonNullDao_callsRefreshOnDao() {
         mCategory.__setDaoSession(mockDaoSession)
         mCategory.refresh()
-        Mockito.verify(mockCategoryDao)!!.refresh(mCategory)
+        verify(mockCategoryDao).refresh(mCategory)
     }
 
     @Test
@@ -88,15 +88,15 @@ class CategoryTest {
     fun updateWithNonNullDao_callsUpdateOnDao() {
         mCategory.__setDaoSession(mockDaoSession)
         mCategory.update()
-        Mockito.verify(mockCategoryDao)!!.update(mCategory)
+        verify(mockCategoryDao).update(mCategory)
     }
 
     @Test
     fun resetNames_callsGetLabelNameDao() {
         mCategory.__setDaoSession(mockDaoSession)
         mCategory.resetNames()
         mCategory.names
-        Mockito.verify(mockDaoSession)!!.categoryNameDao
+        verify(mockDaoSession).categoryNameDao
     }
 
     companion object {