Merge branch 'release/5.69.0' into main

Author: malmstein

app/schemas/com.duckduckgo.app.global.db.AppDatabase/26.json

@@ -122,6 +122,7 @@ import org.mockito.ArgumentMatchers.anyString
 import org.mockito.Mockito.never
 import org.mockito.Mockito.verify
 import java.io.File
+import java.util.*
 import java.util.concurrent.TimeUnit
 
 @ExperimentalCoroutinesApi
@@ -250,7 +251,6 @@ class BrowserTabViewModelTest {
     @Before
     fun before() {
         MockitoAnnotations.initMocks(this)
-
         db = Room.inMemoryDatabaseBuilder(getInstrumentation().targetContext, AppDatabase::class.java)
             .allowMainThreadQueries()
             .build()
@@ -1634,13 +1634,13 @@ class BrowserTabViewModelTest {
 
     @Test
     fun whenScheduledSurveyChangesAndInstalledDaysMatchThenCtaIsSurvey() {
-        testee.onSurveyChanged(Survey("abc", "http://example.com", daysInstalled = 1, status = Survey.Status.SCHEDULED))
+        testee.onSurveyChanged(Survey("abc", "http://example.com", daysInstalled = 1, status = Survey.Status.SCHEDULED), Locale.US)
         assertTrue(testee.ctaViewState.value!!.cta is HomePanelCta.Survey)
     }
 
     @Test
     fun whenScheduledSurveyChangesAndInstalledDaysDontMatchThenCtaIsNull() {
-        testee.onSurveyChanged(Survey("abc", "http://example.com", daysInstalled = 2, status = Survey.Status.SCHEDULED))
+        testee.onSurveyChanged(Survey("abc", "http://example.com", daysInstalled = 2, status = Survey.Status.SCHEDULED), Locale.US)
         assertNull(testee.ctaViewState.value!!.cta)
     }
 
@@ -2668,6 +2668,39 @@ class BrowserTabViewModelTest {
         assertCommandNotIssued<Command.ShowDomainHasPermissionMessage>()
     }
 
+    @Test
+    fun whenUserRefreshesASiteLocationMessageIsNotShownAgain() = coroutineRule.runBlocking {
+        val domain = "https://www.example.com/"
+
+        givenUserAlreadySelectedPermissionForDomain(domain, LocationPermissionType.ALLOW_ALWAYS)
+        givenCurrentSite(domain)
+        givenDeviceLocationSharingIsEnabled(true)
+        givenLocationPermissionIsEnabled(true)
+
+        loadUrl("https://www.example.com", isBrowserShowing = true)
+
+        assertCommandIssued<Command.ShowDomainHasPermissionMessage>()
+
+        loadUrl("https://www.example.com", isBrowserShowing = true)
+
+        assertCommandIssuedTimes<Command.ShowDomainHasPermissionMessage>(1)
+    }
+
+    @Test
+    fun whenUserSelectsPermissionAndRefreshesPageThenLocationMessageIsNotShown() = coroutineRule.runBlocking {
+        val domain = "http://example.com"
+
+        givenCurrentSite(domain)
+        givenDeviceLocationSharingIsEnabled(true)
+        givenLocationPermissionIsEnabled(true)
+
+        testee.onSiteLocationPermissionSelected(domain, LocationPermissionType.ALLOW_ALWAYS)
+
+        loadUrl(domain, isBrowserShowing = true)
+
+        assertCommandNotIssued<Command.ShowDomainHasPermissionMessage>()
+    }
+
     @Test
     fun whenSystemLocationPermissionIsDeniedThenSiteLocationPermissionIsAlwaysDenied() = coroutineRule.runBlocking {
         val domain = "https://www.example.com/"
@@ -2983,6 +3016,11 @@ class BrowserTabViewModelTest {
         assertNull(issuedCommand)
     }
 
+    private inline fun <reified T : Command> assertCommandIssuedTimes(times: Int) {
+        val timesIssued = commandCaptor.allValues.count { it is T }
+        assertEquals(times, timesIssued)
+    }
+
     private fun pixelParams(showedBookmarks: Boolean, bookmarkCapable: Boolean) = mapOf(
         Pixel.PixelParameter.SHOWED_BOOKMARKS to showedBookmarks.toString(),
         Pixel.PixelParameter.BOOKMARK_CAPABLE to bookmarkCapable.toString()

app/src/androidTest/java/com/duckduckgo/app/browser/BrowserTabViewModelTest.kt

@@ -68,6 +68,7 @@ import org.junit.Rule
 import org.junit.Test
 import org.mockito.Mock
 import org.mockito.MockitoAnnotations
+import java.util.*
 import java.util.concurrent.TimeUnit
 
 @FlowPreview
@@ -145,7 +146,6 @@ class CtaViewModelTest {
     @Before
     fun before() {
         MockitoAnnotations.initMocks(this)
-
         val context = InstrumentationRegistry.getInstrumentation().targetContext
         db = Room.inMemoryDatabaseBuilder(context, AppDatabase::class.java)
             .allowMainThreadQueries()
@@ -180,16 +180,43 @@ class CtaViewModelTest {
     }
 
     @Test
-    fun whenScheduledSurveyChangesAndInstalledDaysMatchThenCtaIsSurvey() {
-        val survey = Survey("abc", "http://example.com", 1, SCHEDULED)
+    fun whenScheduledSurveyChangesAndInstalledDaysMatchAndLocaleIsUsThenCtaIsSurvey() = coroutineRule.runBlocking {
+        testee.onSurveyChanged(Survey("abc", "http://example.com", 1, SCHEDULED))
+        val value = testee.refreshCta(coroutineRule.testDispatcher, isBrowserShowing = false, site = null, locale = Locale.US)
+        assertTrue(value is HomePanelCta.Survey)
+    }
+
+    @Test
+    fun whenScheduledSurveyChangesAndInstalledDaysMatchButLocaleIsNotUsThenCtaIsNotSurvey() = coroutineRule.runBlocking {
+        testee.onSurveyChanged(Survey("abc", "http://example.com", 1, SCHEDULED))
+        val value = testee.refreshCta(coroutineRule.testDispatcher, isBrowserShowing = false, site = null, locale = Locale.CANADA)
+        assertFalse(value is HomePanelCta.Survey)
+    }
+
+    @Test
+    fun whenScheduledSurveyIsNullThenCtaIsNotSurvey() = coroutineRule.runBlocking {
+        val value = testee.refreshCta(coroutineRule.testDispatcher, isBrowserShowing = false, site = null, locale = Locale.US)
+        assertFalse(value is HomePanelCta.Survey)
+    }
+
+    @Test
+    fun whenScheduledSurveyChangesFromNullToNullThenClearedIsFalse() {
+        val value = testee.onSurveyChanged(null)
+        assertFalse(value)
+    }
+
+    @Test
+    fun whenScheduledSurveyChangesFromNullToASurveyThenClearedIsFalse() {
+        testee.onSurveyChanged(null)
         val value = testee.onSurveyChanged(Survey("abc", "http://example.com", 1, SCHEDULED))
-        assertEquals(survey, value)
+        assertFalse(value)
     }
 
     @Test
-    fun whenScheduledSurveyIsNullThenCtaIsNotSurvey() {
+    fun whenScheduledSurveyChangesFromASurveyToNullThenClearedIsTrue() {
+        testee.onSurveyChanged(Survey("abc", "http://example.com", 1, SCHEDULED))
         val value = testee.onSurveyChanged(null)
-        assertNull(value)
+        assertTrue(value)
     }
 
     @Test

app/src/androidTest/java/com/duckduckgo/app/cta/ui/CtaViewModelTest.kt

@@ -17,30 +17,24 @@
 package com.duckduckgo.app.httpsupgrade
 
 import android.net.Uri
-import com.duckduckgo.app.httpsupgrade.api.HttpsBloomFilterFactory
-import com.duckduckgo.app.httpsupgrade.api.HttpsUpgradeService
-import com.duckduckgo.app.httpsupgrade.db.HttpsWhitelistDao
+import com.duckduckgo.app.httpsupgrade.store.HttpsFalsePositivesDao
 import com.duckduckgo.app.privacy.db.UserWhitelistDao
 import com.duckduckgo.app.statistics.pixels.Pixel
-import com.nhaarman.mockitokotlin2.any
 import com.nhaarman.mockitokotlin2.mock
 import com.nhaarman.mockitokotlin2.whenever
-import okhttp3.ResponseBody
 import org.junit.Assert.assertFalse
 import org.junit.Assert.assertTrue
 import org.junit.Before
 import org.junit.Test
 import retrofit2.Call
-import retrofit2.Response
 
 class HttpsUpgraderTest {
 
     lateinit var testee: HttpsUpgrader
 
     private var mockHttpsBloomFilterFactory: HttpsBloomFilterFactory = mock()
-    private var mockWhitelistDao: HttpsWhitelistDao = mock()
-    private var mockUserWhitelistDao: UserWhitelistDao = mock()
-    private var mockUpgradeService: HttpsUpgradeService = mock()
+    private var mockBloomFalsePositiveListDao: HttpsFalsePositivesDao = mock()
+    private var mockUserAllowlistDao: UserWhitelistDao = mock()
     private var mockServiceCall: Call<List<String>> = mock()
 
     private var mockPixel: Pixel = mock()
@@ -49,84 +43,43 @@ class HttpsUpgraderTest {
     @Before
     fun before() {
         whenever(mockHttpsBloomFilterFactory.create()).thenReturn(bloomFilter)
-        testee = HttpsUpgraderImpl(mockWhitelistDao, mockUserWhitelistDao, mockHttpsBloomFilterFactory, mockUpgradeService, mockPixel)
+        testee = HttpsUpgraderImpl(mockHttpsBloomFilterFactory, mockBloomFalsePositiveListDao, mockUserAllowlistDao, mockPixel)
         testee.reloadData()
     }
 
     @Test
-    fun whenHttpUriIsInLocalListThenShouldUpgrade() {
+    fun whenHttpUriIsInBloomThenShouldUpgrade() {
         bloomFilter.add("www.local.url")
         assertTrue(testee.shouldUpgrade(Uri.parse("http://www.local.url")))
+        mockPixel.fire(Pixel.PixelName.HTTPS_LOCAL_UPGRADE)
+    }
+
+    @Test
+    fun whenHttpUriIsNotInBloomThenShouldNotUpgrade() {
+        bloomFilter.add("www.local.url")
+        assertFalse(testee.shouldUpgrade(Uri.parse("http://www.differentlocal.url")))
+        mockPixel.fire(Pixel.PixelName.HTTPS_NO_UPGRADE)
     }
 
     @Test
     fun whenHttpsUriThenShouldNotUpgrade() {
+        bloomFilter.add("www.local.url")
         assertFalse(testee.shouldUpgrade(Uri.parse("https://www.local.url")))
+        mockPixel.fire(Pixel.PixelName.HTTPS_NO_UPGRADE)
     }
 
     @Test
     fun whenHttpUriHasOnlyPartDomainInLocalListThenShouldNotUpgrade() {
         bloomFilter.add("local.url")
         assertFalse(testee.shouldUpgrade(Uri.parse("http://www.local.url")))
-    }
-
-    @Test
-    fun whenHttpDomainIsUserWhitelistedThenShouldNotUpgradeAndNoLookupPixelIsSet() {
-        whenever(mockUserWhitelistDao.contains("www.local.url")).thenReturn(true)
-        bloomFilter.add("www.local.url")
-        assertFalse(testee.shouldUpgrade(Uri.parse("http://www.local.url")))
         mockPixel.fire(Pixel.PixelName.HTTPS_NO_LOOKUP)
     }
 
     @Test
-    fun whenHttpUriIsInLocalListAndInWhitelistThenShouldNotUpgrade() {
+    fun whenHttpDomainIsUserWhitelistedThenShouldNotUpgrade() {
         bloomFilter.add("www.local.url")
-        whenever(mockWhitelistDao.contains("www.local.url")).thenReturn(true)
+        whenever(mockUserAllowlistDao.contains("www.local.url")).thenReturn(true)
         assertFalse(testee.shouldUpgrade(Uri.parse("http://www.local.url")))
-    }
-
-    @Test
-    fun whenHttpUriIsNotInLocalListButCanBeUpgradedByServiceThenShouldUpgrade() {
-        whenever(mockServiceCall.execute()).thenReturn(Response.success(serviceResponse()))
-        whenever(mockUpgradeService.upgradeListForPartialHost(any())).thenReturn(mockServiceCall)
-        assertTrue(testee.shouldUpgrade(Uri.parse("http://service.url")))
-    }
-
-    @Test
-    fun whenHttpUriIsNotInLocalListAndCannotBeUpgradedByServiceThenShouldNotUpgrade() {
-        whenever(mockServiceCall.execute()).thenReturn(Response.success(serviceResponse()))
-        whenever(mockUpgradeService.upgradeListForPartialHost(any())).thenReturn(mockServiceCall)
-        assertFalse(testee.shouldUpgrade(Uri.parse("http://unknown.com")))
-    }
-
-    @Test
-    fun whenHttpUriIsNotInLocalListAndServiceRequestFailsThenShouldNotUpgrade() {
-        whenever(mockServiceCall.execute()).thenReturn(Response.error(500, ResponseBody.create(null, "")))
-        whenever(mockUpgradeService.upgradeListForPartialHost(any())).thenReturn(mockServiceCall)
-        assertFalse(testee.shouldUpgrade(Uri.parse("http://service.url")))
-    }
-
-    @Test
-    fun whenBloomFilterIsNotLoadedAndUrlIsInServiceListThenShouldUpgrade() {
-        whenever(mockHttpsBloomFilterFactory.create()).thenReturn(null)
-        whenever(mockServiceCall.execute()).thenReturn(Response.success(serviceResponse()))
-        whenever(mockUpgradeService.upgradeListForPartialHost(any())).thenReturn(mockServiceCall)
-        assertTrue(testee.shouldUpgrade(Uri.parse("http://service.url")))
-    }
-
-    @Test
-    fun testWhenBloomFilterIsNotLoadedAndUrlNotInServiceListThenShouldNotUpgrade() {
-        whenever(mockHttpsBloomFilterFactory.create()).thenReturn(null)
-        whenever(mockServiceCall.execute()).thenReturn(Response.success(serviceResponse()))
-        whenever(mockUpgradeService.upgradeListForPartialHost(any())).thenReturn(mockServiceCall)
-        assertFalse(testee.shouldUpgrade(Uri.parse("http://unknown.com")))
-    }
-
-    private fun serviceResponse(): List<String> {
-        return arrayListOf(
-            "cfb1a171724ad0b8f108526d6a201667f74691e4",
-            "cfb10e3da9ae3bc2ba7e4641c911987da63aa0a7",
-            "cfb18efe21acd63556dd75bcae7003a2fff90752"
-        )
+        mockPixel.fire(Pixel.PixelName.HTTPS_NO_LOOKUP)
     }
 }

app/src/androidTest/java/com/duckduckgo/app/httpsupgrade/HttpsUpgraderTest.kt

@@ -16,21 +16,21 @@
 
 package com.duckduckgo.app.httpsupgrade.api
 
-import com.duckduckgo.app.httpsupgrade.model.HttpsWhitelistedDomain
+import com.duckduckgo.app.httpsupgrade.model.HttpsFalsePositiveDomain
 import com.squareup.moshi.JsonAdapter
 import com.squareup.moshi.Moshi
 import com.squareup.moshi.Types
 import org.junit.Assert.assertEquals
 import org.junit.Test
 
-class HttpsWhitelistJsonTest {
+class HttpsFalsePositivesJsonTest {
 
     @Test
     fun whenGivenValidJsonThenParsesCorrectly() {
 
-        val moshi = Moshi.Builder().add(HttpsWhitelistJsonAdapter()).build()
-        val type = Types.newParameterizedType(List::class.java, HttpsWhitelistedDomain::class.java)
-        val jsonAdapter: JsonAdapter<List<HttpsWhitelistedDomain>> = moshi.adapter(type)
+        val moshi = Moshi.Builder().add(HttpsFalsePositivesJsonAdapter()).build()
+        val type = Types.newParameterizedType(List::class.java, HttpsFalsePositiveDomain::class.java)
+        val jsonAdapter: JsonAdapter<List<HttpsFalsePositiveDomain>> = moshi.adapter(type)
 
         val list = jsonAdapter.fromJson(json())!!
         assertEquals(7, list.count())

app/src/androidTest/java/com/duckduckgo/app/httpsupgrade/api/HttpsWhitelistJsonTest.kt renamed to app/src/androidTest/java/com/duckduckgo/app/httpsupgrade/api/HttpsFalsePositivesJsonTest.kt

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package com.duckduckgo.app.httpsupgrade.db
+package com.duckduckgo.app.httpsupgrade.store
 
 import androidx.room.Room
 import androidx.test.platform.app.InstrumentationRegistry
@@ -48,17 +48,18 @@ class HttpsBloomFilterSpecDaoTest {
 
     @Test
     fun whenModelIsInsertedThenGetIsNotNull() {
-        dao.insert(HttpsBloomFilterSpec(errorRate = 0.1, totalEntries = 55, sha256 = "abc"))
+        dao.insert(HttpsBloomFilterSpec(errorRate = 0.1, bitCount = 1000, totalEntries = 55, sha256 = "abc"))
         assertNotNull(dao.get())
     }
 
     @Test
     fun whenNewModelIsInsertedThenGetIsNotNullAndDetailsUpdates() {
-        dao.insert(HttpsBloomFilterSpec(errorRate = 0.1, totalEntries = 55, sha256 = "abc"))
-        dao.insert(HttpsBloomFilterSpec(errorRate = 0.2, totalEntries = 60, sha256 = "xyz"))
+        dao.insert(HttpsBloomFilterSpec(bitCount = 1000, errorRate = 0.1, totalEntries = 55, sha256 = "abc"))
+        dao.insert(HttpsBloomFilterSpec(bitCount = 2000, errorRate = 0.2, totalEntries = 60, sha256 = "xyz"))
 
         val specification = dao.get()
         assertNotNull(specification)
+        assertEquals(2000, specification!!.bitCount)
         assertEquals(0.2, specification!!.errorRate, 0.01)
         assertEquals(60, specification.totalEntries)
         assertEquals("xyz", specification.sha256)