mobile/android/fenix/app/src/androidTest/java/org/mozilla/fenix/ui/SettingsSitePermissionsTest.kt

   1 /* This Source Code Form is subject to the terms of the Mozilla Public
   2  * License, v. 2.0. If a copy of the MPL was not distributed with this
   3  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   4
   5 package org.mozilla.fenix.ui
   6
   7 import androidx.core.net.toUri
   8 import androidx.test.espresso.Espresso.pressBack
   9 import androidx.test.filters.SdkSuppress
  10 import mozilla.components.concept.engine.mediasession.MediaSession
  11 import org.junit.Ignore
  12 import org.junit.Rule
  13 import org.junit.Test
  14 import org.mozilla.fenix.customannotations.SmokeTest
  15 import org.mozilla.fenix.helpers.AppAndSystemHelper.grantSystemPermission
  16 import org.mozilla.fenix.helpers.HomeActivityTestRule
  17 import org.mozilla.fenix.helpers.MatcherHelper.itemWithText
  18 import org.mozilla.fenix.helpers.TestAssetHelper.getGenericAsset
  19 import org.mozilla.fenix.helpers.TestAssetHelper.getMutedVideoPageAsset
  20 import org.mozilla.fenix.helpers.TestAssetHelper.getVideoPageAsset
  21 import org.mozilla.fenix.helpers.TestHelper.exitMenu
  22 import org.mozilla.fenix.helpers.TestSetup
  23 import org.mozilla.fenix.ui.robots.browserScreen
  24 import org.mozilla.fenix.ui.robots.clickPageObject
  25 import org.mozilla.fenix.ui.robots.homeScreen
  26 import org.mozilla.fenix.ui.robots.navigationToolbar
  27
  28 /**
  29  *  Tests for verifying
  30  *  - site permissions settings sub-menu
  31  *  - the settings effects on the app behavior
  32  *
  33  */
  34 class SettingsSitePermissionsTest : TestSetup() {
  35     /* Test page created and handled by the Mozilla mobile test-eng team */
  36     private val permissionsTestPage = "https://mozilla-mobile.github.io/testapp/v2.0/permissions"
  37     private val permissionsTestPageHost = "https://mozilla-mobile.github.io"
  38     private val testPageSubstring = "https://mozilla-mobile.github.io:443"
  39
  40     @get:Rule
  41     val activityTestRule = HomeActivityTestRule(
  42         isJumpBackInCFREnabled = false,
  43         isPWAsPromptEnabled = false,
  44         isTCPCFREnabled = false,
  45         isDeleteSitePermissionsEnabled = true,
  46     )
  47
  48     // TestRail link: https://testrail.stage.mozaws.net/index.php?/cases/view/246974
  49     @Test
  50     fun sitePermissionsItemsTest() {
  51         homeScreen {
  52         }.openThreeDotMenu {
  53         }.openSettings {
  54         }.openSettingsSubMenuSitePermissions {
  55             verifySitePermissionsToolbarTitle()
  56             verifyToolbarGoBackButton()
  57             verifySitePermissionOption("Autoplay", "Block audio only")
  58             verifySitePermissionOption("Camera", "Blocked by Android")
  59             verifySitePermissionOption("Location", "Blocked by Android")
  60             verifySitePermissionOption("Microphone", "Blocked by Android")
  61             verifySitePermissionOption("Notification", "Ask to allow")
  62             verifySitePermissionOption("Persistent Storage", "Ask to allow")
  63             verifySitePermissionOption("Cross-site cookies", "Ask to allow")
  64             verifySitePermissionOption("DRM-controlled content", "Ask to allow")
  65             verifySitePermissionOption("Exceptions")
  66         }
  67     }
  68
  69     // TestRail link: https://testrail.stage.mozaws.net/index.php?/cases/view/247680
  70     // Verifies that you can go to System settings and change app's permissions from inside the app
  71     @SmokeTest
  72     @Test
  73     @SdkSuppress(minSdkVersion = 29)
  74     fun systemBlockedPermissionsRedirectToSystemAppSettingsTest() {
  75         homeScreen {
  76         }.openThreeDotMenu {
  77         }.openSettings {
  78         }.openSettingsSubMenuSitePermissions {
  79         }.openCamera {
  80             verifyBlockedByAndroidSection()
  81         }.goBack {
  82         }.openLocation {
  83             verifyBlockedByAndroidSection()
  84         }.goBack {
  85         }.openMicrophone {
  86             verifyBlockedByAndroidSection()
  87             clickGoToSettingsButton()
  88             openAppSystemPermissionsSettings()
  89             switchAppPermissionSystemSetting("Camera", "Allow")
  90             goBackToSystemAppPermissionSettings()
  91             verifySystemGrantedPermission("Camera")
  92             switchAppPermissionSystemSetting("Location", "Allow")
  93             goBackToSystemAppPermissionSettings()
  94             verifySystemGrantedPermission("Location")
  95             switchAppPermissionSystemSetting("Microphone", "Allow")
  96             goBackToSystemAppPermissionSettings()
  97             verifySystemGrantedPermission("Microphone")
  98             goBackToPermissionsSettingsSubMenu()
  99             verifyUnblockedByAndroid()
 100         }.goBack {
 101         }.openLocation {
 102             verifyUnblockedByAndroid()
 103         }.goBack {
 104         }.openCamera {
 105             verifyUnblockedByAndroid()
 106         }
 107     }
 108
 109     // TestRail link: https://testrail.stage.mozaws.net/index.php?/cases/view/2095125
 110     @SmokeTest
 111     @Test
 112     fun verifyAutoplayBlockAudioOnlySettingOnNotMutedVideoTest() {
 113         val genericPage = getGenericAsset(mockWebServer, 1)
 114         val videoTestPage = getVideoPageAsset(mockWebServer)
 115
 116         homeScreen {
 117         }.openThreeDotMenu {
 118         }.openSettings {
 119         }.openSettingsSubMenuSitePermissions {
 120         }.openAutoPlay {
 121             verifySitePermissionsAutoPlaySubMenuItems()
 122             exitMenu()
 123         }
 124         navigationToolbar {
 125         }.enterURLAndEnterToBrowser(genericPage.url) {
 126             verifyPageContent(genericPage.content)
 127         }.openTabDrawer {
 128             closeTab()
 129         }
 130         navigationToolbar {
 131         }.enterURLAndEnterToBrowser(videoTestPage.url) {
 132             try {
 133                 verifyPageContent(videoTestPage.content)
 134                 clickPageObject(itemWithText("Play"))
 135                 assertPlaybackState(browserStore, MediaSession.PlaybackState.PLAYING)
 136             } catch (e: java.lang.AssertionError) {
 137                 navigationToolbar {
 138                 }.openThreeDotMenu {
 139                 }.refreshPage {
 140                     verifyPageContent(videoTestPage.content)
 141                     clickPageObject(itemWithText("Play"))
 142                     assertPlaybackState(browserStore, MediaSession.PlaybackState.PLAYING)
 143                 }
 144             }
 145         }
 146     }
 147
 148     // TestRail link: https://testrail.stage.mozaws.net/index.php?/cases/view/2286807
 149     @Ignore("Failing, see https://bugzilla.mozilla.org/show_bug.cgi?id=1827599")
 150     @SmokeTest
 151     @Test
 152     fun verifyAutoplayBlockAudioOnlySettingOnMutedVideoTest() {
 153         val genericPage = getGenericAsset(mockWebServer, 1)
 154         val mutedVideoTestPage = getMutedVideoPageAsset(mockWebServer)
 155
 156         navigationToolbar {
 157         }.enterURLAndEnterToBrowser(genericPage.url) {
 158             verifyPageContent(genericPage.content)
 159         }.openTabDrawer {
 160             closeTab()
 161         }
 162         navigationToolbar {
 163         }.enterURLAndEnterToBrowser(mutedVideoTestPage.url) {
 164             try {
 165                 verifyPageContent("Media file is playing")
 166             } catch (e: java.lang.AssertionError) {
 167                 navigationToolbar {
 168                 }.openThreeDotMenu {
 169                 }.refreshPage {
 170                     verifyPageContent("Media file is playing")
 171                 }
 172             }
 173         }
 174     }
 175
 176     // TestRail link: https://testrail.stage.mozaws.net/index.php?/cases/view/2095124
 177     @Test
 178     fun verifyAutoplayAllowAudioVideoSettingOnNotMutedVideoTestTest() {
 179         val genericPage = getGenericAsset(mockWebServer, 1)
 180         val videoTestPage = getVideoPageAsset(mockWebServer)
 181
 182         homeScreen {
 183         }.openThreeDotMenu {
 184         }.openSettings {
 185         }.openSettingsSubMenuSitePermissions {
 186         }.openAutoPlay {
 187             selectAutoplayOption("Allow audio and video")
 188             exitMenu()
 189         }
 190         navigationToolbar {
 191         }.enterURLAndEnterToBrowser(genericPage.url) {
 192             verifyPageContent(genericPage.content)
 193         }.openTabDrawer {
 194             closeTab()
 195         }
 196         navigationToolbar {
 197         }.enterURLAndEnterToBrowser(videoTestPage.url) {
 198             try {
 199                 verifyPageContent(videoTestPage.content)
 200                 assertPlaybackState(browserStore, MediaSession.PlaybackState.PLAYING)
 201             } catch (e: java.lang.AssertionError) {
 202                 navigationToolbar {
 203                 }.openThreeDotMenu {
 204                 }.refreshPage {
 205                     verifyPageContent(videoTestPage.content)
 206                     assertPlaybackState(browserStore, MediaSession.PlaybackState.PLAYING)
 207                 }
 208             }
 209         }
 210     }
 211
 212     // TestRail link: https://testrail.stage.mozaws.net/index.php?/cases/view/2286806
 213     @Ignore("Failing, see https://bugzilla.mozilla.org/show_bug.cgi?id=1827599")
 214     @Test
 215     fun verifyAutoplayAllowAudioVideoSettingOnMutedVideoTest() {
 216         val mutedVideoTestPage = getMutedVideoPageAsset(mockWebServer)
 217
 218         homeScreen {
 219         }.openThreeDotMenu {
 220         }.openSettings {
 221         }.openSettingsSubMenuSitePermissions {
 222         }.openAutoPlay {
 223             selectAutoplayOption("Allow audio and video")
 224             exitMenu()
 225         }
 226         navigationToolbar {
 227         }.enterURLAndEnterToBrowser(mutedVideoTestPage.url) {
 228             try {
 229                 verifyPageContent("Media file is playing")
 230             } catch (e: java.lang.AssertionError) {
 231                 navigationToolbar {
 232                 }.openThreeDotMenu {
 233                 }.refreshPage {
 234                     verifyPageContent("Media file is playing")
 235                 }
 236             }
 237         }
 238     }
 239
 240     // TestRail link: https://testrail.stage.mozaws.net/index.php?/cases/view/2095126
 241     @Test
 242     fun verifyAutoplayBlockAudioAndVideoSettingOnNotMutedVideoTest() {
 243         val videoTestPage = getVideoPageAsset(mockWebServer)
 244
 245         homeScreen {
 246         }.openThreeDotMenu {
 247         }.openSettings {
 248         }.openSettingsSubMenuSitePermissions {
 249         }.openAutoPlay {
 250             selectAutoplayOption("Block audio and video")
 251             exitMenu()
 252         }
 253         navigationToolbar {
 254         }.enterURLAndEnterToBrowser(videoTestPage.url) {
 255             try {
 256                 verifyPageContent(videoTestPage.content)
 257                 clickPageObject(itemWithText("Play"))
 258                 assertPlaybackState(browserStore, MediaSession.PlaybackState.PLAYING)
 259             } catch (e: java.lang.AssertionError) {
 260                 navigationToolbar {
 261                 }.openThreeDotMenu {
 262                 }.refreshPage {
 263                     verifyPageContent(videoTestPage.content)
 264                     clickPageObject(itemWithText("Play"))
 265                     assertPlaybackState(browserStore, MediaSession.PlaybackState.PLAYING)
 266                 }
 267             }
 268         }
 269     }
 270
 271     // TestRail link: https://testrail.stage.mozaws.net/index.php?/cases/view/2286808
 272     @Test
 273     fun verifyAutoplayBlockAudioAndVideoSettingOnMutedVideoTest() {
 274         val mutedVideoTestPage = getMutedVideoPageAsset(mockWebServer)
 275
 276         homeScreen {
 277         }.openThreeDotMenu {
 278         }.openSettings {
 279         }.openSettingsSubMenuSitePermissions {
 280         }.openAutoPlay {
 281             selectAutoplayOption("Block audio and video")
 282             exitMenu()
 283         }
 284         navigationToolbar {
 285         }.enterURLAndEnterToBrowser(mutedVideoTestPage.url) {
 286             verifyPageContent("Media file not playing")
 287             clickPageObject(itemWithText("Play"))
 288             try {
 289                 verifyPageContent("Media file is playing")
 290             } catch (e: java.lang.AssertionError) {
 291                 navigationToolbar {
 292                 }.openThreeDotMenu {
 293                 }.refreshPage {
 294                     clickPageObject(itemWithText("Play"))
 295                     verifyPageContent("Media file is playing")
 296                 }
 297             }
 298         }
 299     }
 300
 301     // TestRail link: https://testrail.stage.mozaws.net/index.php?/cases/view/247362
 302     @Test
 303     fun verifyCameraPermissionSettingsTest() {
 304         navigationToolbar {
 305         }.enterURLAndEnterToBrowser(permissionsTestPage.toUri()) {
 306         }.clickStartCameraButton {
 307             grantSystemPermission()
 308             verifyCameraPermissionPrompt(testPageSubstring)
 309             pressBack()
 310         }
 311         browserScreen {
 312             navigationToolbar {
 313             }.openThreeDotMenu {
 314             }.openSettings {
 315             }.openSettingsSubMenuSitePermissions {
 316             }.openCamera {
 317                 verifySitePermissionsCommonSubMenuItems()
 318                 selectPermissionSettingOption("Blocked")
 319                 exitMenu()
 320             }
 321         }.clickStartCameraButton {}
 322         browserScreen {
 323             verifyPageContent("Camera not allowed")
 324         }
 325     }
 326
 327     // TestRail link: https://testrail.stage.mozaws.net/index.php?/cases/view/247364
 328     @Test
 329     fun verifyMicrophonePermissionSettingsTest() {
 330         navigationToolbar {
 331         }.enterURLAndEnterToBrowser(permissionsTestPage.toUri()) {
 332         }.clickStartMicrophoneButton {
 333             grantSystemPermission()
 334             verifyMicrophonePermissionPrompt(testPageSubstring)
 335             pressBack()
 336         }
 337         browserScreen {
 338             navigationToolbar {
 339             }.openThreeDotMenu {
 340             }.openSettings {
 341             }.openSettingsSubMenuSitePermissions {
 342             }.openMicrophone {
 343                 verifySitePermissionsCommonSubMenuItems()
 344                 selectPermissionSettingOption("Blocked")
 345                 exitMenu()
 346             }
 347         }.clickStartMicrophoneButton {}
 348         browserScreen {
 349             verifyPageContent("Microphone not allowed")
 350         }
 351     }
 352
 353     // TestRail link: https://testrail.stage.mozaws.net/index.php?/cases/view/247363
 354     @Test
 355     fun verifyLocationPermissionSettingsTest() {
 356         navigationToolbar {
 357         }.enterURLAndEnterToBrowser(permissionsTestPage.toUri()) {
 358         }.clickGetLocationButton {
 359             verifyLocationPermissionPrompt(testPageSubstring)
 360             pressBack()
 361         }
 362         browserScreen {
 363             navigationToolbar {
 364             }.openThreeDotMenu {
 365             }.openSettings {
 366             }.openSettingsSubMenuSitePermissions {
 367             }.openLocation {
 368                 verifySitePermissionsCommonSubMenuItems()
 369                 selectPermissionSettingOption("Blocked")
 370                 exitMenu()
 371             }
 372         }.clickGetLocationButton {}
 373         browserScreen {
 374             verifyPageContent("User denied geolocation prompt")
 375         }
 376     }
 377
 378     // TestRail link: https://testrail.stage.mozaws.net/index.php?/cases/view/247365
 379     @Test
 380     fun verifyNotificationsPermissionSettingsTest() {
 381         navigationToolbar {
 382         }.enterURLAndEnterToBrowser(permissionsTestPage.toUri()) {
 383         }.clickOpenNotificationButton {
 384             verifyNotificationsPermissionPrompt(testPageSubstring)
 385             pressBack()
 386         }
 387         browserScreen {
 388             navigationToolbar {
 389             }.openThreeDotMenu {
 390             }.openSettings {
 391             }.openSettingsSubMenuSitePermissions {
 392             }.openNotification {
 393                 verifyNotificationSubMenuItems()
 394                 selectPermissionSettingOption("Blocked")
 395                 exitMenu()
 396             }
 397         }.clickOpenNotificationButton {}
 398         browserScreen {
 399             verifyPageContent("Notifications not allowed")
 400         }
 401     }
 402
 403     // TestRail link: https://testrail.stage.mozaws.net/index.php?/cases/view/1923415
 404     @Test
 405     fun verifyPersistentStoragePermissionSettingsTest() {
 406         navigationToolbar {
 407         }.enterURLAndEnterToBrowser(permissionsTestPage.toUri()) {
 408         }.clickRequestPersistentStorageAccessButton {
 409             verifyPersistentStoragePermissionPrompt(testPageSubstring)
 410             pressBack()
 411         }
 412         browserScreen {
 413             navigationToolbar {
 414             }.openThreeDotMenu {
 415             }.openSettings {
 416             }.openSettingsSubMenuSitePermissions {
 417             }.openPersistentStorage {
 418                 verifySitePermissionsPersistentStorageSubMenuItems()
 419                 selectPermissionSettingOption("Blocked")
 420                 exitMenu()
 421             }
 422         }.clickRequestPersistentStorageAccessButton {}
 423         browserScreen {
 424             verifyPageContent("Persistent storage permission denied")
 425         }
 426     }
 427
 428     // TestRail link: https://testrail.stage.mozaws.net/index.php?/cases/view/1923417
 429     @Test
 430     fun verifyDRMControlledContentPermissionSettingsTest() {
 431         navigationToolbar {
 432         }.enterURLAndEnterToBrowser(permissionsTestPage.toUri()) {
 433         }.clickRequestDRMControlledContentAccessButton {
 434             verifyDRMContentPermissionPrompt(testPageSubstring)
 435             pressBack()
 436             browserScreen {
 437             }.openThreeDotMenu {
 438             }.openSettings {
 439             }.openSettingsSubMenuSitePermissions {
 440             }.openDRMControlledContent {
 441                 verifyDRMControlledContentSubMenuItems()
 442                 selectDRMControlledContentPermissionSettingOption("Blocked")
 443                 exitMenu()
 444             }
 445             browserScreen {
 446             }.clickRequestDRMControlledContentAccessButton {}
 447             browserScreen {
 448                 verifyPageContent("DRM-controlled content not allowed")
 449             }.openThreeDotMenu {
 450             }.openSettings {
 451             }.openSettingsSubMenuSitePermissions {
 452             }.openDRMControlledContent {
 453                 selectDRMControlledContentPermissionSettingOption("Allowed")
 454                 exitMenu()
 455             }
 456             browserScreen {
 457             }.openThreeDotMenu {
 458             }.refreshPage {
 459             }.clickRequestDRMControlledContentAccessButton {}
 460             browserScreen {
 461                 verifyPageContent("DRM-controlled content allowed")
 462             }
 463         }
 464     }
 465
 466     // TestRail link: https://testrail.stage.mozaws.net/index.php?/cases/view/246976
 467     @SmokeTest
 468     @Test
 469     fun clearAllSitePermissionsExceptionsTest() {
 470         navigationToolbar {
 471         }.enterURLAndEnterToBrowser(permissionsTestPage.toUri()) {
 472         }.clickOpenNotificationButton {
 473             verifyNotificationsPermissionPrompt(testPageSubstring)
 474         }.clickPagePermissionButton(true) {
 475         }.openThreeDotMenu {
 476         }.openSettings {
 477         }.openSettingsSubMenuSitePermissions {
 478         }.openExceptions {
 479             verifyExceptionCreated(permissionsTestPageHost, true)
 480             clickClearPermissionsOnAllSites()
 481             verifyClearPermissionsDialog()
 482             clickCancel()
 483             clickClearPermissionsOnAllSites()
 484             clickOK()
 485             verifyExceptionsEmptyList()
 486         }
 487     }
 488
 489     // TestRail link: https://testrail.stage.mozaws.net/index.php?/cases/view/247007
 490     @Test
 491     fun addAndClearOneWebPagePermission() {
 492         navigationToolbar {
 493         }.enterURLAndEnterToBrowser(permissionsTestPage.toUri()) {
 494         }.clickOpenNotificationButton {
 495             verifyNotificationsPermissionPrompt(testPageSubstring)
 496         }.clickPagePermissionButton(true) {
 497         }.openThreeDotMenu {
 498         }.openSettings {
 499         }.openSettingsSubMenuSitePermissions {
 500         }.openExceptions {
 501             verifyExceptionCreated(permissionsTestPageHost, true)
 502             openSiteExceptionsDetails(permissionsTestPageHost)
 503             clickClearPermissionsForOneSite()
 504             verifyClearPermissionsForOneSiteDialog()
 505             clickCancel()
 506             clickClearPermissionsForOneSite()
 507             clickOK()
 508             verifyExceptionsEmptyList()
 509         }
 510     }
 511
 512     // TestRail link: https://testrail.stage.mozaws.net/index.php?/cases/view/326477
 513     @Test
 514     fun clearIndividuallyAWebPagePermission() {
 515         navigationToolbar {
 516         }.enterURLAndEnterToBrowser(permissionsTestPage.toUri()) {
 517         }.clickOpenNotificationButton {
 518             verifyNotificationsPermissionPrompt(testPageSubstring)
 519         }.clickPagePermissionButton(true) {
 520         }.openThreeDotMenu {
 521         }.openSettings {
 522         }.openSettingsSubMenuSitePermissions {
 523         }.openExceptions {
 524             verifyExceptionCreated(permissionsTestPageHost, true)
 525             openSiteExceptionsDetails(permissionsTestPageHost)
 526             verifyPermissionSettingSummary("Notification", "Allowed")
 527             openChangePermissionSettingsMenu("Notification")
 528             clickClearOnePermissionForOneSite()
 529             verifyResetPermissionDefaultForThisSiteDialog()
 530             clickOK()
 531             pressBack()
 532             verifyPermissionSettingSummary("Notification", "Ask to allow")
 533             pressBack()
 534             // This should be changed to false, when https://bugzilla.mozilla.org/show_bug.cgi?id=1826297 is fixed
 535             verifyExceptionCreated(permissionsTestPageHost, true)
 536         }
 537     }
 538 }