mobile/android/fenix/app/src/androidTest/java/org/mozilla/fenix/ui/SitePermissionsTest.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 android.Manifest
   8 import android.content.Context
   9 import android.hardware.camera2.CameraManager
  10 import android.media.AudioManager
  11 import android.os.Build
  12 import androidx.core.net.toUri
  13 import androidx.test.rule.GrantPermissionRule
  14 import org.junit.Assume.assumeTrue
  15 import org.junit.Rule
  16 import org.junit.Test
  17 import org.mozilla.fenix.customannotations.SmokeTest
  18 import org.mozilla.fenix.helpers.AppAndSystemHelper.assertExternalAppOpens
  19 import org.mozilla.fenix.helpers.AppAndSystemHelper.grantSystemPermission
  20 import org.mozilla.fenix.helpers.HomeActivityIntentTestRule
  21 import org.mozilla.fenix.helpers.MatcherHelper.itemWithResId
  22 import org.mozilla.fenix.helpers.MockLocationUpdatesRule
  23 import org.mozilla.fenix.helpers.RetryTestRule
  24 import org.mozilla.fenix.helpers.TestAssetHelper
  25 import org.mozilla.fenix.helpers.TestHelper.appContext
  26 import org.mozilla.fenix.helpers.TestSetup
  27 import org.mozilla.fenix.ui.robots.browserScreen
  28 import org.mozilla.fenix.ui.robots.clickPageObject
  29 import org.mozilla.fenix.ui.robots.navigationToolbar
  30
  31 /**
  32  *  Tests for verifying site permissions prompts & functionality
  33  *
  34  */
  35 class SitePermissionsTest : TestSetup() {
  36     /* Test page created and handled by the Mozilla mobile test-eng team */
  37     private val testPage = "https://mozilla-mobile.github.io/testapp/permissions"
  38     private val testPageSubstring = "https://mozilla-mobile.github.io:443"
  39     private val cameraManager = appContext.getSystemService(Context.CAMERA_SERVICE) as CameraManager
  40     private val micManager = appContext.getSystemService(Context.AUDIO_SERVICE) as AudioManager
  41
  42     @get:Rule
  43     val activityTestRule = HomeActivityIntentTestRule(
  44         isJumpBackInCFREnabled = false,
  45         isPWAsPromptEnabled = false,
  46         isTCPCFREnabled = false,
  47         isDeleteSitePermissionsEnabled = true,
  48     )
  49
  50     @get:Rule
  51     val grantPermissionRule: GrantPermissionRule = GrantPermissionRule.grant(
  52         Manifest.permission.RECORD_AUDIO,
  53         Manifest.permission.CAMERA,
  54         Manifest.permission.ACCESS_COARSE_LOCATION,
  55     )
  56
  57     @get: Rule
  58     val mockLocationUpdatesRule = MockLocationUpdatesRule()
  59
  60     @get: Rule
  61     val retryTestRule = RetryTestRule(3)
  62
  63     // TestRail link: https://testrail.stage.mozaws.net/index.php?/cases/view/2334295
  64     @SmokeTest
  65     @Test
  66     fun audioVideoPermissionWithoutRememberingTheDecisionTest() {
  67         assumeTrue(cameraManager.cameraIdList.isNotEmpty())
  68
  69         navigationToolbar {
  70         }.enterURLAndEnterToBrowser(testPage.toUri()) {
  71             waitForPageToLoad()
  72         }.clickStartAudioVideoButton {
  73             verifyAudioVideoPermissionPrompt(testPageSubstring)
  74         }.clickPagePermissionButton(false) {
  75             verifyPageContent("Camera and Microphone not allowed")
  76         }.clickStartAudioVideoButton {
  77         }.clickPagePermissionButton(true) {
  78             verifyPageContent("Camera and Microphone allowed")
  79         }
  80     }
  81
  82     // TestRail link: https://testrail.stage.mozaws.net/index.php?/cases/view/2334294
  83     @Test
  84     fun blockAudioVideoPermissionRememberingTheDecisionTest() {
  85         assumeTrue(cameraManager.cameraIdList.isNotEmpty())
  86         assumeTrue(micManager.microphones.isNotEmpty())
  87
  88         navigationToolbar {
  89         }.enterURLAndEnterToBrowser(testPage.toUri()) {
  90             waitForPageToLoad()
  91         }.clickStartAudioVideoButton {
  92             verifyAudioVideoPermissionPrompt(testPageSubstring)
  93             selectRememberPermissionDecision()
  94         }.clickPagePermissionButton(false) {
  95             verifyPageContent("Camera and Microphone not allowed")
  96         }.openThreeDotMenu {
  97         }.refreshPage {
  98             waitForPageToLoad()
  99         }.clickStartAudioVideoButton { }
 100         browserScreen {
 101             verifyPageContent("Camera and Microphone not allowed")
 102         }
 103     }
 104
 105     // TestRail link: https://testrail.stage.mozaws.net/index.php?/cases/view/251388
 106     @Test
 107     fun allowAudioVideoPermissionRememberingTheDecisionTest() {
 108         assumeTrue(cameraManager.cameraIdList.isNotEmpty())
 109         assumeTrue(micManager.microphones.isNotEmpty())
 110
 111         navigationToolbar {
 112         }.enterURLAndEnterToBrowser(testPage.toUri()) {
 113             waitForPageToLoad()
 114         }.clickStartAudioVideoButton {
 115             verifyAudioVideoPermissionPrompt(testPageSubstring)
 116             selectRememberPermissionDecision()
 117         }.clickPagePermissionButton(true) {
 118             verifyPageContent("Camera and Microphone allowed")
 119         }.openThreeDotMenu {
 120         }.refreshPage {
 121             waitForPageToLoad()
 122         }.clickStartAudioVideoButton { }
 123         browserScreen {
 124             verifyPageContent("Camera and Microphone allowed")
 125         }
 126     }
 127
 128     // TestRail link: https://testrail.stage.mozaws.net/index.php?/cases/view/2334189
 129     @Test
 130     fun microphonePermissionWithoutRememberingTheDecisionTest() {
 131         assumeTrue(micManager.microphones.isNotEmpty())
 132
 133         navigationToolbar {
 134         }.enterURLAndEnterToBrowser(testPage.toUri()) {
 135             waitForPageToLoad()
 136         }.clickStartMicrophoneButton {
 137             verifyMicrophonePermissionPrompt(testPageSubstring)
 138         }.clickPagePermissionButton(false) {
 139             verifyPageContent("Microphone not allowed")
 140         }.clickStartMicrophoneButton {
 141         }.clickPagePermissionButton(true) {
 142             verifyPageContent("Microphone allowed")
 143         }
 144     }
 145
 146     // TestRail link: https://testrail.stage.mozaws.net/index.php?/cases/view/2334190
 147     @Test
 148     fun blockMicrophonePermissionRememberingTheDecisionTest() {
 149         assumeTrue(micManager.microphones.isNotEmpty())
 150
 151         navigationToolbar {
 152         }.enterURLAndEnterToBrowser(testPage.toUri()) {
 153             waitForPageToLoad()
 154         }.clickStartMicrophoneButton {
 155             verifyMicrophonePermissionPrompt(testPageSubstring)
 156             selectRememberPermissionDecision()
 157         }.clickPagePermissionButton(false) {
 158             verifyPageContent("Microphone not allowed")
 159         }.openThreeDotMenu {
 160         }.refreshPage {
 161             waitForPageToLoad()
 162         }.clickStartMicrophoneButton { }
 163         browserScreen {
 164             verifyPageContent("Microphone not allowed")
 165         }
 166     }
 167
 168     // TestRail link: https://testrail.stage.mozaws.net/index.php?/cases/view/251387
 169     @Test
 170     fun allowMicrophonePermissionRememberingTheDecisionTest() {
 171         assumeTrue(micManager.microphones.isNotEmpty())
 172
 173         navigationToolbar {
 174         }.enterURLAndEnterToBrowser(testPage.toUri()) {
 175             waitForPageToLoad()
 176         }.clickStartMicrophoneButton {
 177             verifyMicrophonePermissionPrompt(testPageSubstring)
 178             selectRememberPermissionDecision()
 179         }.clickPagePermissionButton(true) {
 180             verifyPageContent("Microphone allowed")
 181         }.openThreeDotMenu {
 182         }.refreshPage {
 183             waitForPageToLoad()
 184         }.clickStartMicrophoneButton { }
 185         browserScreen {
 186             verifyPageContent("Microphone allowed")
 187         }
 188     }
 189
 190     // TestRail link: https://testrail.stage.mozaws.net/index.php?/cases/view/2334076
 191     @Test
 192     fun cameraPermissionWithoutRememberingDecisionTest() {
 193         assumeTrue(cameraManager.cameraIdList.isNotEmpty())
 194
 195         navigationToolbar {
 196         }.enterURLAndEnterToBrowser(testPage.toUri()) {
 197             waitForPageToLoad()
 198         }.clickStartCameraButton {
 199             verifyCameraPermissionPrompt(testPageSubstring)
 200         }.clickPagePermissionButton(false) {
 201             verifyPageContent("Camera not allowed")
 202         }.clickStartCameraButton {
 203         }.clickPagePermissionButton(true) {
 204             verifyPageContent("Camera allowed")
 205         }
 206     }
 207
 208     // TestRail link: https://testrail.stage.mozaws.net/index.php?/cases/view/2334077
 209     @Test
 210     fun blockCameraPermissionRememberingTheDecisionTest() {
 211         assumeTrue(cameraManager.cameraIdList.isNotEmpty())
 212
 213         navigationToolbar {
 214         }.enterURLAndEnterToBrowser(testPage.toUri()) {
 215             waitForPageToLoad()
 216         }.clickStartCameraButton {
 217             verifyCameraPermissionPrompt(testPageSubstring)
 218             selectRememberPermissionDecision()
 219         }.clickPagePermissionButton(false) {
 220             verifyPageContent("Camera not allowed")
 221         }.openThreeDotMenu {
 222         }.refreshPage {
 223             waitForPageToLoad()
 224         }.clickStartCameraButton { }
 225         browserScreen {
 226             verifyPageContent("Camera not allowed")
 227         }
 228     }
 229
 230     // TestRail link: https://testrail.stage.mozaws.net/index.php?/cases/view/251386
 231     @Test
 232     fun allowCameraPermissionRememberingTheDecisionTest() {
 233         assumeTrue(cameraManager.cameraIdList.isNotEmpty())
 234
 235         navigationToolbar {
 236         }.enterURLAndEnterToBrowser(testPage.toUri()) {
 237             waitForPageToLoad()
 238         }.clickStartCameraButton {
 239             verifyCameraPermissionPrompt(testPageSubstring)
 240             selectRememberPermissionDecision()
 241         }.clickPagePermissionButton(true) {
 242             verifyPageContent("Camera allowed")
 243         }.openThreeDotMenu {
 244         }.refreshPage {
 245             waitForPageToLoad()
 246         }.clickStartCameraButton { }
 247         browserScreen {
 248             verifyPageContent("Camera allowed")
 249         }
 250     }
 251
 252     // TestRail link: https://testrail.stage.mozaws.net/index.php?/cases/view/2334074
 253     @SmokeTest
 254     @Test
 255     fun blockNotificationsPermissionTest() {
 256         navigationToolbar {
 257         }.enterURLAndEnterToBrowser(testPage.toUri()) {
 258         }.clickOpenNotificationButton {
 259             verifyNotificationsPermissionPrompt(testPageSubstring)
 260         }.clickPagePermissionButton(false) {
 261             verifyPageContent("Notifications not allowed")
 262         }.openThreeDotMenu {
 263         }.refreshPage {
 264             waitForPageToLoad()
 265         }.clickOpenNotificationButton {
 266             verifyNotificationsPermissionPrompt(testPageSubstring, true)
 267         }
 268     }
 269
 270     // TestRail link: https://testrail.stage.mozaws.net/index.php?/cases/view/251380
 271     @Test
 272     fun allowNotificationsPermissionTest() {
 273         navigationToolbar {
 274         }.enterURLAndEnterToBrowser(testPage.toUri()) {
 275         }.clickOpenNotificationButton {
 276             verifyNotificationsPermissionPrompt(testPageSubstring)
 277         }.clickPagePermissionButton(true) {
 278             verifyPageContent("Notifications allowed")
 279         }
 280     }
 281
 282     // TestRail link: https://testrail.stage.mozaws.net/index.php?/cases/view/251385
 283     @SmokeTest
 284     @Test
 285     fun allowLocationPermissionsTest() {
 286         mockLocationUpdatesRule.setMockLocation()
 287
 288         navigationToolbar {
 289         }.enterURLAndEnterToBrowser(testPage.toUri()) {
 290         }.clickGetLocationButton {
 291             verifyLocationPermissionPrompt(testPageSubstring)
 292         }.clickPagePermissionButton(true) {
 293             verifyPageContent("${mockLocationUpdatesRule.latitude}")
 294             verifyPageContent("${mockLocationUpdatesRule.longitude}")
 295         }
 296     }
 297
 298     // TestRail link: https://testrail.stage.mozaws.net/index.php?/cases/view/2334075
 299     @Test
 300     fun blockLocationPermissionsTest() {
 301         navigationToolbar {
 302         }.enterURLAndEnterToBrowser(testPage.toUri()) {
 303         }.clickGetLocationButton {
 304             verifyLocationPermissionPrompt(testPageSubstring)
 305         }.clickPagePermissionButton(false) {
 306             verifyPageContent("User denied geolocation prompt")
 307         }
 308     }
 309
 310     // TestRail link: https://testrail.stage.mozaws.net/index.php?/cases/view/2121537
 311     @SmokeTest
 312     @Test
 313     fun fileUploadPermissionTest() {
 314         val testPage = TestAssetHelper.getHTMLControlsFormAsset(mockWebServer)
 315
 316         navigationToolbar {
 317         }.enterURLAndEnterToBrowser(testPage.url) {
 318             clickPageObject(itemWithResId("upload_file"))
 319             grantSystemPermission()
 320             if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
 321                 assertExternalAppOpens("com.google.android.documentsui")
 322             } else {
 323                 assertExternalAppOpens("com.android.documentsui")
 324             }
 325         }
 326     }
 327 }