diff --git a/app/src/main/java/openfoodfacts/github/scrachx/openfood/utils/Utils.kt b/app/src/main/java/openfoodfacts/github/scrachx/openfood/utils/Utils.kt index e5de01fa651d..b1c80d148bac 100644 --- a/app/src/main/java/openfoodfacts/github/scrachx/openfood/utils/Utils.kt +++ b/app/src/main/java/openfoodfacts/github/scrachx/openfood/utils/Utils.kt @@ -240,17 +240,19 @@ fun ViewGroup.getViewsByType(typeClass: Class): List { /** * @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") } /** diff --git a/app/src/test/java/openfoodfacts/github/scrachx/openfood/category/CategoryRepositoryTest.kt b/app/src/test/java/openfoodfacts/github/scrachx/openfood/category/CategoryRepositoryTest.kt index 449440533cf9..b01ff1a3dd3f 100644 --- a/app/src/test/java/openfoodfacts/github/scrachx/openfood/category/CategoryRepositoryTest.kt +++ b/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 any(type: Class): T = Mockito.any(type) - @Test fun retrieveAll_Success() { val testObserver = TestObserver>() repository.retrieveAll().subscribe(testObserver) testObserver.awaitTerminalEvent() + val result = testObserver.values()[0] - Truth.assertThat(result[0]).isEqualTo(category) + assertThat(result[0]).isEqualTo(category) } } \ No newline at end of file diff --git a/app/src/test/java/openfoodfacts/github/scrachx/openfood/models/ModifierTest.kt b/app/src/test/java/openfoodfacts/github/scrachx/openfood/models/ModifierTest.kt index 624c7bea9949..d55533a7c281 100644 --- a/app/src/test/java/openfoodfacts/github/scrachx/openfood/models/ModifierTest.kt +++ b/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() + 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) } } diff --git a/app/src/test/java/openfoodfacts/github/scrachx/openfood/models/NutrimentTest.kt b/app/src/test/java/openfoodfacts/github/scrachx/openfood/models/NutrimentTest.kt index 309a17a414c3..7ff6ecf49310 100644 --- a/app/src/test/java/openfoodfacts/github/scrachx/openfood/models/NutrimentTest.kt +++ b/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) } diff --git a/app/src/test/java/openfoodfacts/github/scrachx/openfood/models/entities/additive/AdditiveTest.kt b/app/src/test/java/openfoodfacts/github/scrachx/openfood/models/entities/additive/AdditiveTest.kt index 8e7081b64d13..afccdf00f0a9 100644 --- a/app/src/test/java/openfoodfacts/github/scrachx/openfood/models/entities/additive/AdditiveTest.kt +++ b/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 { diff --git a/app/src/test/java/openfoodfacts/github/scrachx/openfood/models/entities/analysistag/AnalysisTagTest.kt b/app/src/test/java/openfoodfacts/github/scrachx/openfood/models/entities/analysistag/AnalysisTagTest.kt index 38e44bcf23d7..3abd209fc29d 100644 --- a/app/src/test/java/openfoodfacts/github/scrachx/openfood/models/entities/analysistag/AnalysisTagTest.kt +++ b/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 @@ -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() } } \ No newline at end of file diff --git a/app/src/test/java/openfoodfacts/github/scrachx/openfood/models/entities/category/CategoryTest.kt b/app/src/test/java/openfoodfacts/github/scrachx/openfood/models/entities/category/CategoryTest.kt index f3849bce4d9a..3d9d0a0aa352 100644 --- a/app/src/test/java/openfoodfacts/github/scrachx/openfood/models/entities/category/CategoryTest.kt +++ b/app/src/test/java/openfoodfacts/github/scrachx/openfood/models/entities/category/CategoryTest.kt @@ -1,17 +1,18 @@ 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] @@ -19,21 +20,20 @@ import org.mockito.Mockito.`when` as mockitoWhen @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,7 +88,7 @@ class CategoryTest { fun updateWithNonNullDao_callsUpdateOnDao() { mCategory.__setDaoSession(mockDaoSession) mCategory.update() - Mockito.verify(mockCategoryDao)!!.update(mCategory) + verify(mockCategoryDao).update(mCategory) } @Test @@ -96,7 +96,7 @@ class CategoryTest { mCategory.__setDaoSession(mockDaoSession) mCategory.resetNames() mCategory.names - Mockito.verify(mockDaoSession)!!.categoryNameDao + verify(mockDaoSession).categoryNameDao } companion object { diff --git a/app/src/test/java/openfoodfacts/github/scrachx/openfood/models/entities/country/CountryTest.kt b/app/src/test/java/openfoodfacts/github/scrachx/openfood/models/entities/country/CountryTest.kt index 69fa4cbcfade..767a2c3bd5c6 100644 --- a/app/src/test/java/openfoodfacts/github/scrachx/openfood/models/entities/country/CountryTest.kt +++ b/app/src/test/java/openfoodfacts/github/scrachx/openfood/models/entities/country/CountryTest.kt @@ -11,11 +11,12 @@ 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.verify 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 [Country] @@ -24,21 +25,20 @@ import org.mockito.Mockito.`when` as mockitoWhen class CountryTest { @Mock - private val mockDaoSession: DaoSession? = null + private lateinit var mockDaoSession: DaoSession @Mock - private val mockCountryDao: CountryDao? = null + private lateinit var mockCountryDao: CountryDao @Mock - private val mockCountryNameDao: CountryNameDao? = null + private lateinit var mockCountryNameDao: CountryNameDao private lateinit var mCountry: Country @Before fun setup() { - mockitoWhen(mockDaoSession!!.countryDao).thenReturn(mockCountryDao) - mockitoWhen(mockDaoSession.countryNameDao).thenReturn(mockCountryNameDao) - mockitoWhen(mockCountryNameDao!!._queryCountry_Names(ArgumentMatchers.any())) - .thenReturn(listOf(GERMANY_IN_ENGLISH, GERMANY_IN_FRENCH)) + whenever(mockDaoSession.countryDao) doReturn mockCountryDao + whenever(mockDaoSession.countryNameDao) doReturn mockCountryNameDao + whenever(mockCountryNameDao._queryCountry_Names(any())) doReturn listOf(GERMANY_IN_ENGLISH, GERMANY_IN_FRENCH) mCountry = Country() } @@ -50,14 +50,19 @@ class CountryTest { @Test fun getNamesWithNullNamesAndNonNullDaoSession_getsNamesFromCountryNamesDao() { mCountry.__setDaoSession(mockDaoSession) + val names = mCountry.names assertThat(names).hasSize(2) - assertThat(names[0]!!.countyTag).isEqualTo(COUNTRY_TAG) - assertThat(names[0]!!.languageCode).isEqualTo(LANGUAGE_CODE_ENGLISH) - assertThat(names[0]!!.name).isEqualTo(GERMANY_EN) - assertThat(names[1]!!.countyTag).isEqualTo(COUNTRY_TAG) - assertThat(names[1]!!.languageCode).isEqualTo(LANGUAGE_CODE_FRENCH) - assertThat(names[1]!!.name).isEqualTo(GERMANY_FR) + + val countryName1 = names[0]!! + assertThat(countryName1.countyTag).isEqualTo(COUNTRY_TAG) + assertThat(countryName1.languageCode).isEqualTo(LANGUAGE_CODE_ENGLISH) + assertThat(countryName1.name).isEqualTo(GERMANY_EN) + + val countryName2 = names[1]!! + assertThat(countryName2.countyTag).isEqualTo(COUNTRY_TAG) + assertThat(countryName2.languageCode).isEqualTo(LANGUAGE_CODE_FRENCH) + assertThat(countryName2.name).isEqualTo(GERMANY_FR) } @Test @@ -69,7 +74,7 @@ class CountryTest { fun deleteWithNonNullDaoSession_callsDeleteOnCountryDao() { mCountry.__setDaoSession(mockDaoSession) mCountry.delete() - verify(mockCountryDao)!!.delete(mCountry) + verify(mockCountryDao).delete(mCountry) } @Test @@ -81,7 +86,7 @@ class CountryTest { fun refreshWithNonNullDaoSession_callsRefreshOnCountryDao() { mCountry.__setDaoSession(mockDaoSession) mCountry.refresh() - verify(mockCountryDao)!!.refresh(mCountry) + verify(mockCountryDao).refresh(mCountry) } @Test @@ -93,7 +98,7 @@ class CountryTest { fun updateWithNonNullDaoSession_callsUpdateOnCountryDao() { mCountry.__setDaoSession(mockDaoSession) mCountry.update() - verify(mockCountryDao)!!.update(mCountry) + verify(mockCountryDao).update(mCountry) } companion object { diff --git a/app/src/test/java/openfoodfacts/github/scrachx/openfood/models/entities/label/LabelTest.kt b/app/src/test/java/openfoodfacts/github/scrachx/openfood/models/entities/label/LabelTest.kt index 5c210ab922b9..053ea991369e 100644 --- a/app/src/test/java/openfoodfacts/github/scrachx/openfood/models/entities/label/LabelTest.kt +++ b/app/src/test/java/openfoodfacts/github/scrachx/openfood/models/entities/label/LabelTest.kt @@ -16,7 +16,8 @@ import org.mockito.ArgumentMatchers import org.mockito.Mock 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 [Label] @@ -24,35 +25,35 @@ import org.mockito.Mockito.`when` as mockitoWhen @RunWith(MockitoJUnitRunner::class) class LabelTest { @Mock - private val mockDaoSession: DaoSession? = null + private lateinit var mockDaoSession: DaoSession @Mock - private val mockLabelDao: LabelDao? = null + private lateinit var mockLabelDao: LabelDao @Mock private val mockLabelNameDao: LabelNameDao? = null - private var mLabel: Label? = null + + private lateinit var mLabel: Label @Before fun setup() { - mockitoWhen(mockDaoSession!!.labelDao).thenReturn(mockLabelDao) - mockitoWhen(mockDaoSession.labelNameDao).thenReturn(mockLabelNameDao) + whenever(mockDaoSession.labelDao) doReturn mockLabelDao + whenever(mockDaoSession.labelNameDao) doReturn mockLabelNameDao val labelName1 = LabelName(LABEL_TAG, LANGUAGE_CODE_ENGLISH, LABEL_NAME_EN) val labelName2 = LabelName(LABEL_TAG, LANGUAGE_CODE_FRENCH, LABEL_NAME_FR) - mockitoWhen(mockLabelNameDao!!._queryLabel_Names(ArgumentMatchers.any())) - .thenReturn(listOf(labelName1, labelName2)) + whenever(mockLabelNameDao!!._queryLabel_Names(ArgumentMatchers.any())) doReturn listOf(labelName1, labelName2) mLabel = Label() } @Test fun getNamesWithNullNamesAndNullDaoSession_throwsDaoException() { - Assert.assertThrows(DaoException::class.java) { mLabel!!.names } + Assert.assertThrows(DaoException::class.java) { mLabel.names } } @Test fun getNamesWithNullNamesAndNonNullDaoSession_getsNamesFromLabelNameDao() { - mLabel!!.__setDaoSession(mockDaoSession) - val labelNames = mLabel!!.names + mLabel.__setDaoSession(mockDaoSession) + val labelNames = mLabel.names Truth.assertThat(labelNames).hasSize(2) val labelName1 = labelNames[0] Truth.assertThat(labelName1!!.labelTag).isEqualTo(LABEL_TAG) @@ -66,45 +67,45 @@ class LabelTest { @Test fun deleteWithNullDaoSession_throwsDaoException() { - Assert.assertThrows(DaoException::class.java) { mLabel!!.delete() } + Assert.assertThrows(DaoException::class.java) { mLabel.delete() } } @Test fun deleteWithNonNullDaoSession_callsDeleteOnLabelDao() { - mLabel!!.__setDaoSession(mockDaoSession) - mLabel!!.delete() + mLabel.__setDaoSession(mockDaoSession) + mLabel.delete() verify(mockLabelDao)!!.delete(mLabel) } @Test fun refreshWithNullDaoSession_throwsDaoException() { - Assert.assertThrows(DaoException::class.java) { mLabel!!.refresh() } + Assert.assertThrows(DaoException::class.java) { mLabel.refresh() } } @Test fun refreshWithNonNullDaoSession_callsRefreshOnLabelDao() { - mLabel!!.__setDaoSession(mockDaoSession) - mLabel!!.refresh() + mLabel.__setDaoSession(mockDaoSession) + mLabel.refresh() verify(mockLabelDao)!!.refresh(mLabel) } @Test fun updateWithNullDaoSession_throwsDaoException() { - Assert.assertThrows(DaoException::class.java) { mLabel!!.update() } + Assert.assertThrows(DaoException::class.java) { mLabel.update() } } @Test fun updateWithNonNullDaoSession_callsUpdateOnLabelDao() { - mLabel!!.__setDaoSession(mockDaoSession) - mLabel!!.update() + mLabel.__setDaoSession(mockDaoSession) + mLabel.update() verify(mockLabelDao)!!.update(mLabel) } @Test fun resetNames_callsGetLabelNameDao() { - mLabel!!.__setDaoSession(mockDaoSession) - mLabel!!.resetNames() - mLabel!!.names + mLabel.__setDaoSession(mockDaoSession) + mLabel.resetNames() + mLabel.names verify(mockDaoSession)!!.labelNameDao } } \ No newline at end of file diff --git a/app/src/test/java/openfoodfacts/github/scrachx/openfood/utils/LocaleUtilsTest.kt b/app/src/test/java/openfoodfacts/github/scrachx/openfood/utils/LocaleUtilsTest.kt index 6874745346a5..a980d42b823f 100644 --- a/app/src/test/java/openfoodfacts/github/scrachx/openfood/utils/LocaleUtilsTest.kt +++ b/app/src/test/java/openfoodfacts/github/scrachx/openfood/utils/LocaleUtilsTest.kt @@ -7,9 +7,9 @@ import android.content.res.Resources import com.google.common.truth.Truth.assertThat import openfoodfacts.github.scrachx.openfood.models.LanguageData import org.junit.Test -import org.mockito.Mockito.mock +import org.mockito.kotlin.doReturn +import org.mockito.kotlin.mock import java.util.* -import org.mockito.Mockito.`when` as mockitoWhen /** * Created by n27 on 4/4/17. @@ -25,17 +25,18 @@ class LocaleUtilsTest { @Test fun getLocale_FromContext() { - val context = mock(Context::class.java) - val resources = mock(Resources::class.java) - val sharedPreferences = mock(SharedPreferences::class.java) - val localeManager = LocaleManager(context, sharedPreferences) - mockitoWhen(context.resources).thenReturn(resources) - val locale = LocaleUtils.parseLocale("en-US") - val configuration = mock(Configuration::class.java).apply { - this.locale = locale + val configuration = mock { + on { this.locale } doReturn locale + } + val resources = mock { + on { this.configuration } doReturn configuration } - mockitoWhen(resources.configuration).thenReturn(configuration) + val context = mock { + on { this.resources } doReturn resources + } + val sharedPreferences = mock {} + val localeManager = LocaleManager(context, sharedPreferences) assertThat(localeManager.getLocaleFromContext(context)).isEqualTo(locale) } diff --git a/app/src/test/java/openfoodfacts/github/scrachx/openfood/utils/ProductUtilsTest.kt b/app/src/test/java/openfoodfacts/github/scrachx/openfood/utils/ProductUtilsTest.kt index 7bfcbae10383..2774d9cc076f 100644 --- a/app/src/test/java/openfoodfacts/github/scrachx/openfood/utils/ProductUtilsTest.kt +++ b/app/src/test/java/openfoodfacts/github/scrachx/openfood/utils/ProductUtilsTest.kt @@ -4,17 +4,18 @@ import com.google.common.truth.Truth.assertThat import openfoodfacts.github.scrachx.openfood.models.Product import org.junit.Test import org.mockito.Mockito.mock -import org.mockito.Mockito.`when` as mockitoWhen +import org.mockito.kotlin.doReturn +import org.mockito.kotlin.whenever class ProductUtilsTest { @Test fun isPerServingInLiter() { val mockProd = mock(Product::class.java) - mockitoWhen(mockProd.servingSize).thenReturn("3l") + whenever(mockProd.servingSize) doReturn "3l" assertThat(mockProd.isPerServingInLiter()).isTrue() - mockitoWhen(mockProd.servingSize).thenReturn("3oz") + whenever(mockProd.servingSize) doReturn "3oz" assertThat(mockProd.isPerServingInLiter()).isFalse() } @@ -133,5 +134,9 @@ class ProductUtilsTest { "9528722036004", "9634827116517" ).forEach { assertThat(isBarcodeValid(it)).isTrue() } + + listOf( + "9781484506578" + ).forEach { assertThat(isBarcodeValid(it)).isFalse()} } } \ No newline at end of file diff --git a/app/src/test/java/openfoodfacts/github/scrachx/openfood/utils/UtilsTest.kt b/app/src/test/java/openfoodfacts/github/scrachx/openfood/utils/UtilsTest.kt index f18d9e7bbf90..1871e7658306 100644 --- a/app/src/test/java/openfoodfacts/github/scrachx/openfood/utils/UtilsTest.kt +++ b/app/src/test/java/openfoodfacts/github/scrachx/openfood/utils/UtilsTest.kt @@ -7,33 +7,35 @@ import openfoodfacts.github.scrachx.openfood.R import openfoodfacts.github.scrachx.openfood.models.Product import org.junit.Test import org.mockito.Mockito.mock +import org.mockito.kotlin.doReturn +import org.mockito.kotlin.mock +import org.mockito.kotlin.whenever import java.util.* -import org.mockito.Mockito.`when` as mockitoWhen class UtilsTest { @Test fun testGetImageGrade() { val mockProduct = mock(Product::class.java) - mockitoWhen(mockProduct.nutritionGradeFr).thenReturn("a") + whenever(mockProduct.nutritionGradeFr) doReturn "a" assertThat(mockProduct.getNutriScoreResource()).isEqualTo(R.drawable.ic_nutriscore_a) - mockitoWhen(mockProduct.nutritionGradeFr).thenReturn("b") + whenever(mockProduct.nutritionGradeFr) doReturn "b" assertThat(mockProduct.getNutriScoreResource()).isEqualTo(R.drawable.ic_nutriscore_b) - mockitoWhen(mockProduct.nutritionGradeFr).thenReturn("c") + whenever(mockProduct.nutritionGradeFr) doReturn "c" assertThat(mockProduct.getNutriScoreResource()).isEqualTo(R.drawable.ic_nutriscore_c) - mockitoWhen(mockProduct.nutritionGradeFr).thenReturn("d") + whenever(mockProduct.nutritionGradeFr) doReturn "d" assertThat(mockProduct.getNutriScoreResource()).isEqualTo(R.drawable.ic_nutriscore_d) - mockitoWhen(mockProduct.nutritionGradeFr).thenReturn("e") + whenever(mockProduct.nutritionGradeFr) doReturn "e" assertThat(mockProduct.getNutriScoreResource()).isEqualTo(R.drawable.ic_nutriscore_e) - mockitoWhen(mockProduct.nutritionGradeFr).thenReturn("") + whenever(mockProduct.nutritionGradeFr) doReturn "" assertThat(mockProduct.getNutriScoreResource()).isEqualTo(R.drawable.ic_nutriscore_unknown) - mockitoWhen(mockProduct.nutritionGradeFr).thenReturn(null) + whenever(mockProduct.nutritionGradeFr) doReturn null assertThat(mockProduct.getNutriScoreResource()).isEqualTo(R.drawable.ic_nutriscore_unknown) } @@ -53,20 +55,16 @@ class UtilsTest { @Test fun isHardwareCameraInstalled() { - val mockCtx = mock(Context::class.java) - val mockPM = mock(PackageManager::class.java) + val mockPM = mock {} + val mockCtx = mock { + on { this.packageManager } doReturn mockPM + } - mockitoWhen(mockCtx.packageManager).thenReturn(mockPM) - - // Test for best condition - mockitoWhen(mockPM.hasSystemFeature(PackageManager.FEATURE_CAMERA)) - .thenReturn(true) + // Test for true/false + whenever(mockPM.hasSystemFeature(PackageManager.FEATURE_CAMERA)) doReturn true assertThat(isHardwareCameraInstalled(mockCtx)).isTrue() - // False condition - mockitoWhen(mockPM.hasSystemFeature(PackageManager.FEATURE_CAMERA)) - .thenReturn(false) - + whenever(mockPM.hasSystemFeature(PackageManager.FEATURE_CAMERA)) doReturn false assertThat(isHardwareCameraInstalled(mockCtx)).isFalse() }