TB 42089: [android] Remove ability to submit site support requests (0e865979) · Commits · The Tor Project / Applications / Tor Browser

mobile/android/android-components/components/browser/engine-gecko/src/main/java/mozilla/components/browser/engine/gecko/cookiebanners/GeckoCookieBannersStorage.kt

+8 −8

Original line number	Diff line number	Diff line
		@@ -21,7 +21,7 @@ import org.mozilla.geckoview.StorageController
		*/
		class GeckoCookieBannersStorage(
		runtime: GeckoRuntime,
		private val reportSiteDomainsRepository: ReportSiteDomainsRepository,
		// private val reportSiteDomainsRepository: ReportSiteDomainsRepository,
		) : CookieBannersStorage {

		private val geckoStorage: StorageController = runtime.storageController
		@@ -34,13 +34,13 @@ class GeckoCookieBannersStorage(
		setGeckoException(uri, DISABLED, privateBrowsing)
		}

		override suspend fun isSiteDomainReported(siteDomain: String): Boolean {
		return reportSiteDomainsRepository.isSiteDomainReported(siteDomain)
		}

		override suspend fun saveSiteDomain(siteDomain: String) {
		reportSiteDomainsRepository.saveSiteDomain(siteDomain)
		}
		// override suspend fun isSiteDomainReported(siteDomain: String): Boolean {
		// return reportSiteDomainsRepository.isSiteDomainReported(siteDomain)
		// }
		//
		// override suspend fun saveSiteDomain(siteDomain: String) {
		// reportSiteDomainsRepository.saveSiteDomain(siteDomain)
		// }

		override suspend fun addPersistentExceptionInPrivateMode(uri: String) {
		setPersistentPrivateGeckoException(uri, DISABLED)

mobile/android/android-components/components/browser/engine-gecko/src/main/java/mozilla/components/browser/engine/gecko/cookiebanners/ReportSiteDomainsRepository.kt

+55 −55

Original line number	Diff line number	Diff line
		@@ -12,64 +12,64 @@ import androidx.datastore.preferences.core.stringPreferencesKey
		import kotlinx.coroutines.flow.catch
		import kotlinx.coroutines.flow.first
		import kotlinx.coroutines.flow.map
		import mozilla.components.browser.engine.gecko.cookiebanners.ReportSiteDomainsRepository.PreferencesKeys.REPORT_SITE_DOMAINS
		//import mozilla.components.browser.engine.gecko.cookiebanners.ReportSiteDomainsRepository.PreferencesKeys.REPORT_SITE_DOMAINS
		import mozilla.components.support.base.log.logger.Logger
		import java.io.IOException

		/**
		* A repository to save reported site domains with the datastore API.
		*/
		class ReportSiteDomainsRepository(
		private val dataStore: DataStore<Preferences>,
		) {

		companion object {
		const val SEPARATOR = "@<;>@"
		const val REPORT_SITE_DOMAINS_REPOSITORY_NAME = "report_site_domains_preferences"
		const val PREFERENCE_KEY_NAME = "report_site_domains"
		}

		private object PreferencesKeys {
		val REPORT_SITE_DOMAINS = stringPreferencesKey(PREFERENCE_KEY_NAME)
		}

		/**
		* Check if the given site's domain url is saved locally.
		* @param siteDomain the [siteDomain] that will be checked.
		*/
		suspend fun isSiteDomainReported(siteDomain: String): Boolean {
		return dataStore.data
		.catch { exception ->
		if (exception is IOException) {
		Logger.error("Error reading preferences.", exception)
		emit(emptyPreferences())
		} else {
		throw exception
		}
		}.map { preferences ->
		val reportSiteDomainsString = preferences[REPORT_SITE_DOMAINS] ?: ""
		val reportSiteDomainsList =
		reportSiteDomainsString.split(SEPARATOR).filter { it.isNotEmpty() }
		reportSiteDomainsList.contains(siteDomain)
		}.first()
		}

		/**
		* Save the given site's domain url in datastore to keep it persistent locally.
		* This method gets called after the site domain was reported with Nimbus.
		* @param siteDomain the [siteDomain] that will be saved.
		*/
		suspend fun saveSiteDomain(siteDomain: String) {
		dataStore.edit { preferences ->
		val siteDomainsPreferences = preferences[REPORT_SITE_DOMAINS] ?: ""
		val siteDomainsList = siteDomainsPreferences.split(SEPARATOR).filter { it.isNotEmpty() }
		if (siteDomainsList.contains(siteDomain)) {
		return@edit
		}
		val domains = mutableListOf<String>()
		domains.addAll(siteDomainsList)
		domains.add(siteDomain)
		preferences[REPORT_SITE_DOMAINS] = domains.joinToString(SEPARATOR)
		}
		}
		}
		//class ReportSiteDomainsRepository(
		// private val dataStore: DataStore<Preferences>,
		//) {
		//
		// companion object {
		// const val SEPARATOR = "@<;>@"
		// const val REPORT_SITE_DOMAINS_REPOSITORY_NAME = "report_site_domains_preferences"
		// const val PREFERENCE_KEY_NAME = "report_site_domains"
		// }
		//
		// private object PreferencesKeys {
		// val REPORT_SITE_DOMAINS = stringPreferencesKey(PREFERENCE_KEY_NAME)
		// }
		//
		// /**
		// * Check if the given site's domain url is saved locally.
		// * @param siteDomain the [siteDomain] that will be checked.
		// */
		// suspend fun isSiteDomainReported(siteDomain: String): Boolean {
		// return dataStore.data
		// .catch { exception ->
		// if (exception is IOException) {
		// Logger.error("Error reading preferences.", exception)
		// emit(emptyPreferences())
		// } else {
		// throw exception
		// }
		// }.map { preferences ->
		// val reportSiteDomainsString = preferences[REPORT_SITE_DOMAINS] ?: ""
		// val reportSiteDomainsList =
		// reportSiteDomainsString.split(SEPARATOR).filter { it.isNotEmpty() }
		// reportSiteDomainsList.contains(siteDomain)
		// }.first()
		// }
		//
		// /**
		// * Save the given site's domain url in datastore to keep it persistent locally.
		// * This method gets called after the site domain was reported with Nimbus.
		// * @param siteDomain the [siteDomain] that will be saved.
		// */
		// suspend fun saveSiteDomain(siteDomain: String) {
		// dataStore.edit { preferences ->
		// val siteDomainsPreferences = preferences[REPORT_SITE_DOMAINS] ?: ""
		// val siteDomainsList = siteDomainsPreferences.split(SEPARATOR).filter { it.isNotEmpty() }
		// if (siteDomainsList.contains(siteDomain)) {
		// return@edit
		// }
		// val domains = mutableListOf<String>()
		// domains.addAll(siteDomainsList)
		// domains.add(siteDomain)
		// preferences[REPORT_SITE_DOMAINS] = domains.joinToString(SEPARATOR)
		// }
		// }
		//}

mobile/android/android-components/components/browser/engine-gecko/src/test/java/mozilla/components/browser/engine/gecko/cookiebanners/GeckoCookieBannersStorageTest.kt

+132 −132

Original line number	Diff line number	Diff line
		@@ -26,136 +26,136 @@ import org.mozilla.geckoview.StorageController

		@ExperimentalCoroutinesApi
		class GeckoCookieBannersStorageTest {
		private lateinit var runtime: GeckoRuntime
		private lateinit var geckoStorage: GeckoCookieBannersStorage
		private lateinit var storageController: StorageController
		private lateinit var reportSiteDomainsRepository: ReportSiteDomainsRepository

		@Before
		fun setup() {
		storageController = mock()
		runtime = mock()
		reportSiteDomainsRepository = mock()

		whenever(runtime.storageController).thenReturn(storageController)

		geckoStorage = spy(GeckoCookieBannersStorage(runtime, reportSiteDomainsRepository))
		}

		@Test
		fun `GIVEN a cookie banner mode WHEN adding an exception THEN add an exception for the given uri and browsing mode`() =
		runTest {
		val uri = "https://www.mozilla.org"

		doNothing().`when`(geckoStorage)
		.setGeckoException(uri = uri, mode = DISABLED, privateBrowsing = false)

		geckoStorage.addException(uri = uri, privateBrowsing = false)

		verify(geckoStorage).setGeckoException(uri, DISABLED, false)
		}

		@Test
		fun `GIVEN uri and browsing mode WHEN removing an exception THEN remove the exception`() =
		runTest {
		val uri = "https://www.mozilla.org"

		doNothing().`when`(geckoStorage).removeGeckoException(uri, false)

		geckoStorage.removeException(uri = uri, privateBrowsing = false)

		verify(geckoStorage).removeGeckoException(uri, false)
		}

		@Test
		fun `GIVEN uri and browsing mode WHEN querying an exception THEN return the matching exception`() =
		runTest {
		val uri = "https://www.mozilla.org"

		doReturn(REJECT_OR_ACCEPT_ALL).`when`(geckoStorage)
		.queryExceptionInGecko(uri = uri, privateBrowsing = false)

		val result = geckoStorage.findExceptionFor(uri = uri, privateBrowsing = false)
		assertEquals(REJECT_OR_ACCEPT_ALL, result)
		}

		@Test
		fun `GIVEN error WHEN querying an exception THEN return null`() =
		runTest {
		val uri = "https://www.mozilla.org"

		doReturn(null).`when`(geckoStorage)
		.queryExceptionInGecko(uri = uri, privateBrowsing = false)

		val result = geckoStorage.findExceptionFor(uri = uri, privateBrowsing = false)
		assertNull(result)
		}

		@Test
		fun `GIVEN uri and browsing mode WHEN checking for an exception THEN indicate if it has exceptions`() =
		runTest {
		val uri = "https://www.mozilla.org"

		doReturn(REJECT_OR_ACCEPT_ALL).`when`(geckoStorage)
		.queryExceptionInGecko(uri = uri, privateBrowsing = false)

		var result = geckoStorage.hasException(uri = uri, privateBrowsing = false)

		assertFalse(result!!)

		Mockito.reset(geckoStorage)

		doReturn(DISABLED).`when`(geckoStorage)
		.queryExceptionInGecko(uri = uri, privateBrowsing = false)

		result = geckoStorage.hasException(uri = uri, privateBrowsing = false)

		assertTrue(result!!)
		}

		@Test
		fun `GIVEN an error WHEN checking for an exception THEN indicate if that an error happened`() =
		runTest {
		val uri = "https://www.mozilla.org"

		doReturn(null).`when`(geckoStorage)
		.queryExceptionInGecko(uri = uri, privateBrowsing = false)

		val result = geckoStorage.hasException(uri = uri, privateBrowsing = false)

		assertNull(result)
		}

		@Test
		fun `GIVEN a cookie banner mode WHEN adding a persistent exception in private mode THEN add a persistent exception for the given uri in private browsing mode`() =
		runTest {
		val uri = "https://www.mozilla.org"

		doNothing().`when`(geckoStorage)
		.setPersistentPrivateGeckoException(uri = uri, mode = DISABLED)

		geckoStorage.addPersistentExceptionInPrivateMode(uri = uri)

		verify(geckoStorage).setPersistentPrivateGeckoException(uri, DISABLED)
		}

		@Test
		fun `GIVEN site domain url WHEN checking if site domain is reported THEN the report site domain repository gets called`() =
		runTest {
		val reportSiteDomainUrl = "mozilla.org"

		geckoStorage.isSiteDomainReported(reportSiteDomainUrl)

		verify(reportSiteDomainsRepository).isSiteDomainReported(reportSiteDomainUrl)
		}

		@Test
		fun `GIVEN site domain url WHEN saving a site domain THEN the save method from repository should get called`() =
		runTest {
		val reportSiteDomainUrl = "mozilla.org"

		geckoStorage.saveSiteDomain(reportSiteDomainUrl)

		verify(reportSiteDomainsRepository).saveSiteDomain(reportSiteDomainUrl)
		}
		// private lateinit var runtime: GeckoRuntime
		// private lateinit var geckoStorage: GeckoCookieBannersStorage
		// private lateinit var storageController: StorageController
		// private lateinit var reportSiteDomainsRepository: ReportSiteDomainsRepository
		//
		// @Before
		// fun setup() {
		// storageController = mock()
		// runtime = mock()
		// reportSiteDomainsRepository = mock()
		//
		// whenever(runtime.storageController).thenReturn(storageController)
		//
		// geckoStorage = spy(GeckoCookieBannersStorage(runtime, reportSiteDomainsRepository))
		// }
		//
		// @Test
		// fun `GIVEN a cookie banner mode WHEN adding an exception THEN add an exception for the given uri and browsing mode`() =
		// runTest {
		// val uri = "https://www.mozilla.org"
		//
		// doNothing().`when`(geckoStorage)
		// .setGeckoException(uri = uri, mode = DISABLED, privateBrowsing = false)
		//
		// geckoStorage.addException(uri = uri, privateBrowsing = false)
		//
		// verify(geckoStorage).setGeckoException(uri, DISABLED, false)
		// }
		//
		// @Test
		// fun `GIVEN uri and browsing mode WHEN removing an exception THEN remove the exception`() =
		// runTest {
		// val uri = "https://www.mozilla.org"
		//
		// doNothing().`when`(geckoStorage).removeGeckoException(uri, false)
		//
		// geckoStorage.removeException(uri = uri, privateBrowsing = false)
		//
		// verify(geckoStorage).removeGeckoException(uri, false)
		// }
		//
		// @Test
		// fun `GIVEN uri and browsing mode WHEN querying an exception THEN return the matching exception`() =
		// runTest {
		// val uri = "https://www.mozilla.org"
		//
		// doReturn(REJECT_OR_ACCEPT_ALL).`when`(geckoStorage)
		// .queryExceptionInGecko(uri = uri, privateBrowsing = false)
		//
		// val result = geckoStorage.findExceptionFor(uri = uri, privateBrowsing = false)
		// assertEquals(REJECT_OR_ACCEPT_ALL, result)
		// }
		//
		// @Test
		// fun `GIVEN error WHEN querying an exception THEN return null`() =
		// runTest {
		// val uri = "https://www.mozilla.org"
		//
		// doReturn(null).`when`(geckoStorage)
		// .queryExceptionInGecko(uri = uri, privateBrowsing = false)
		//
		// val result = geckoStorage.findExceptionFor(uri = uri, privateBrowsing = false)
		// assertNull(result)
		// }
		//
		// @Test
		// fun `GIVEN uri and browsing mode WHEN checking for an exception THEN indicate if it has exceptions`() =
		// runTest {
		// val uri = "https://www.mozilla.org"
		//
		// doReturn(REJECT_OR_ACCEPT_ALL).`when`(geckoStorage)
		// .queryExceptionInGecko(uri = uri, privateBrowsing = false)
		//
		// var result = geckoStorage.hasException(uri = uri, privateBrowsing = false)
		//
		// assertFalse(result!!)
		//
		// Mockito.reset(geckoStorage)
		//
		// doReturn(DISABLED).`when`(geckoStorage)
		// .queryExceptionInGecko(uri = uri, privateBrowsing = false)
		//
		// result = geckoStorage.hasException(uri = uri, privateBrowsing = false)
		//
		// assertTrue(result!!)
		// }
		//
		// @Test
		// fun `GIVEN an error WHEN checking for an exception THEN indicate if that an error happened`() =
		// runTest {
		// val uri = "https://www.mozilla.org"
		//
		// doReturn(null).`when`(geckoStorage)
		// .queryExceptionInGecko(uri = uri, privateBrowsing = false)
		//
		// val result = geckoStorage.hasException(uri = uri, privateBrowsing = false)
		//
		// assertNull(result)
		// }
		//
		// @Test
		// fun `GIVEN a cookie banner mode WHEN adding a persistent exception in private mode THEN add a persistent exception for the given uri in private browsing mode`() =
		// runTest {
		// val uri = "https://www.mozilla.org"
		//
		// doNothing().`when`(geckoStorage)
		// .setPersistentPrivateGeckoException(uri = uri, mode = DISABLED)
		//
		// geckoStorage.addPersistentExceptionInPrivateMode(uri = uri)
		//
		// verify(geckoStorage).setPersistentPrivateGeckoException(uri, DISABLED)
		// }
		//
		// @Test
		// fun `GIVEN site domain url WHEN checking if site domain is reported THEN the report site domain repository gets called`() =
		// runTest {
		// val reportSiteDomainUrl = "mozilla.org"
		//
		// geckoStorage.isSiteDomainReported(reportSiteDomainUrl)
		//
		// verify(reportSiteDomainsRepository).isSiteDomainReported(reportSiteDomainUrl)
		// }
		//
		// @Test
		// fun `GIVEN site domain url WHEN saving a site domain THEN the save method from repository should get called`() =
		// runTest {
		// val reportSiteDomainUrl = "mozilla.org"
		//
		// geckoStorage.saveSiteDomain(reportSiteDomainUrl)
		//
		// verify(reportSiteDomainsRepository).saveSiteDomain(reportSiteDomainUrl)
		// }
		}

mobile/android/android-components/components/browser/engine-gecko/src/test/java/mozilla/components/browser/engine/gecko/cookiebanners/ReportSiteDomainsRepositoryTest.kt

+48 −48

Original line number	Diff line number	Diff line
		@@ -23,52 +23,52 @@ import org.junit.runner.RunWith
		@ExperimentalCoroutinesApi
		@RunWith(AndroidJUnit4::class)
		class ReportSiteDomainsRepositoryTest {

		companion object {
		const val TEST_DATASTORE_NAME = "test_data_store"
		}

		private lateinit var testDataStore: DataStore<Preferences>

		private lateinit var reportSiteDomainsRepository: ReportSiteDomainsRepository

		@Before
		fun setUp() {
		testDataStore = PreferenceDataStoreFactory.create(
		produceFile = { testContext.preferencesDataStoreFile(TEST_DATASTORE_NAME) },
		)
		reportSiteDomainsRepository = ReportSiteDomainsRepository(testDataStore)
		}

		@After
		fun cleanUp() = runTest { testDataStore.edit { it.clear() } }

		@Test
		fun `GIVEN site domain url WHEN site domain url is not saved THEN is side domain reported return false`() =
		runTest {
		assertFalse(reportSiteDomainsRepository.isSiteDomainReported("mozilla.org"))
		}

		@Test
		fun `GIVEN site domain url WHEN site domain url is saved THEN is side domain reported return true`() =
		runTest {
		val siteDomainReported = "mozilla.org"

		reportSiteDomainsRepository.saveSiteDomain(siteDomainReported)

		assertTrue(reportSiteDomainsRepository.isSiteDomainReported(siteDomainReported))
		}

		@Test
		fun `GIVEN site domain urls WHEN site domain urls are saved THEN is side domain reported return true for each one`() =
		runTest {
		val mozillaSiteDomainReported = "mozilla.org"
		val youtubeSiteDomainReported = "youtube.com"

		reportSiteDomainsRepository.saveSiteDomain(mozillaSiteDomainReported)
		reportSiteDomainsRepository.saveSiteDomain(youtubeSiteDomainReported)

		assertTrue(reportSiteDomainsRepository.isSiteDomainReported(mozillaSiteDomainReported))
		assertTrue(reportSiteDomainsRepository.isSiteDomainReported(youtubeSiteDomainReported))
		}
		//
		// companion object {
		// const val TEST_DATASTORE_NAME = "test_data_store"
		// }
		//
		// private lateinit var testDataStore: DataStore<Preferences>
		//
		// private lateinit var reportSiteDomainsRepository: ReportSiteDomainsRepository
		//
		// @Before
		// fun setUp() {
		// testDataStore = PreferenceDataStoreFactory.create(
		// produceFile = { testContext.preferencesDataStoreFile(TEST_DATASTORE_NAME) },
		// )
		// reportSiteDomainsRepository = ReportSiteDomainsRepository(testDataStore)
		// }
		//
		// @After
		// fun cleanUp() = runTest { testDataStore.edit { it.clear() } }
		//
		// @Test
		// fun `GIVEN site domain url WHEN site domain url is not saved THEN is side domain reported return false`() =
		// runTest {
		// assertFalse(reportSiteDomainsRepository.isSiteDomainReported("mozilla.org"))
		// }
		//
		// @Test
		// fun `GIVEN site domain url WHEN site domain url is saved THEN is side domain reported return true`() =
		// runTest {
		// val siteDomainReported = "mozilla.org"
		//
		// reportSiteDomainsRepository.saveSiteDomain(siteDomainReported)
		//
		// assertTrue(reportSiteDomainsRepository.isSiteDomainReported(siteDomainReported))
		// }
		//
		// @Test
		// fun `GIVEN site domain urls WHEN site domain urls are saved THEN is side domain reported return true for each one`() =
		// runTest {
		// val mozillaSiteDomainReported = "mozilla.org"
		// val youtubeSiteDomainReported = "youtube.com"
		//
		// reportSiteDomainsRepository.saveSiteDomain(mozillaSiteDomainReported)
		// reportSiteDomainsRepository.saveSiteDomain(youtubeSiteDomainReported)
		//
		// assertTrue(reportSiteDomainsRepository.isSiteDomainReported(mozillaSiteDomainReported))
		// assertTrue(reportSiteDomainsRepository.isSiteDomainReported(youtubeSiteDomainReported))
		// }
		}

mobile/android/android-components/components/concept/engine/src/main/java/mozilla/components/concept/engine/cookiehandling/CookieBannersStorage.kt

+2 −2

Original line number	Diff line number	Diff line
		@@ -24,14 +24,14 @@ interface CookieBannersStorage {
		* Check if the given site's domain url is saved locally.
		* @param siteDomain the [siteDomain] that will be checked.
		*/
		suspend fun isSiteDomainReported(siteDomain: String): Boolean
		// suspend fun isSiteDomainReported(siteDomain: String): Boolean

		/**
		* Save the given site's domain url in datastore to keep it persistent locally.
		* This method gets called after the site domain was reported with Nimbus.
		* @param siteDomain the [siteDomain] that will be saved.
		*/
		suspend fun saveSiteDomain(siteDomain: String)
		// suspend fun saveSiteDomain(siteDomain: String)

		/**
		* Set persistently the [CookieBannerHandlingMode.DISABLED] mode for the given [uri] in