def test_unlock_to_homescreen(self): # https://moztrap.mozilla.org/manage/case/1296/ lock_screen = LockScreen(self.marionette) homescreen = lock_screen.unlock() self.wait_for_condition( lambda m: self.apps.displayed_app.name == homescreen.name)
def test_post_camera_preview(self): lock_screen = LockScreen(self.marionette) homescreen = lock_screen.unlock() # Turn off the geolocation prompt, and then launch the camera app self.apps.set_permission('Camera', 'geolocation', 'deny') self.camera = Camera(self.marionette) self.camera.launch() while (self.camera.current_flash_mode != 'off'): self.camera.tap_toggle_flash_button() time.sleep(2) self.marionette.switch_to_frame() camera_frame = Wait(self.marionette, timeout=120).until( expected.element_present(*self._camera_frame_locator)) camera_frame.tap() self.marionette.switch_to_frame(camera_frame) time.sleep(20) self.device.touch_home_button() time.sleep(10) self.device.turn_screen_off() print "" print "Running Post Camera Preview Test" self.runPowerTest("post_idle_camera_preview", "Camera", "camera")
def test_lockscreen_unlock_to_homescreen_with_passcode(self): # Need to wait until the carrier is detected, so the lockscreen will display the carrier information Wait(self.marionette, timeout=30).until(lambda m: self.device.has_mobile_connection) self.data_layer.set_time(self._seconds_since_epoch * 1000) self.data_layer.set_setting('time.timezone', 'Atlantic/Reykjavik') # set passcode-lock self.data_layer.set_setting('lockscreen.passcode-lock.code', self._input_passcode) self.data_layer.set_setting('lockscreen.passcode-lock.enabled', True) # this time we need it locked! self.device.lock() # 1st try lock_screen = LockScreen(self.marionette) lock_screen.switch_to_frame() lock_screen.unlock_to_passcode_pad() self.take_screenshot() self.device.turn_screen_off() # 2nd try self.device.turn_screen_on() passcode_pad = lock_screen.unlock_to_passcode_pad() homescreen = passcode_pad.type_passcode(self._input_passcode) Wait(self.marionette).until( lambda m: self.apps.displayed_app.name == homescreen.name) self.take_screenshot()
def test_unlock_to_homescreen_with_passcode(self): lock_screen = LockScreen(self.marionette) passcode_pad = lock_screen.unlock_to_passcode_pad() homescreen = passcode_pad.type_passcode(self._input_passcode) self.wait_for_condition( lambda m: self.apps.displayed_app.name == homescreen.name)
def test_camera_picture(self): """https://moztrap.mozilla.org/manage/case/1296/""" lock_screen = LockScreen(self.marionette) homescreen = lock_screen.unlock() #self.wait_for_condition(lambda m: self.apps.displayed_app.name == homescreen.name) # Turn off the geolocation prompt, and then launch the camera app self.apps.set_permission('Camera', 'geolocation', 'deny') self.camera = Camera(self.marionette) self.camera.launch() while (self.camera.current_flash_mode != 'off'): self.camera.tap_toggle_flash_button() time.sleep(2) self.marionette.switch_to_frame() camera_frame = Wait(self.marionette, timeout=120).until( expected.element_present(*self._camera_frame_locator)) camera_frame.tap() self.marionette.switch_to_frame(camera_frame) print "" print "Running Camera Picture Test" self.runPowerTest("camera_picture", "Camera", "camera", PICTURE_INTERVAL_TIME, self.take_picture)
def post_idle_wifi_browser_run_test(self, url, test_name, permissionFlag=False): lock_screen = LockScreen(self.marionette) homescreen = lock_screen.unlock() self.data_layer.disable_wifi() # make sure it starts out disabled self.data_layer.connect_to_wifi() print "Connected to wifi" self.apps.switch_to_displayed_app() self.go_to_url(homescreen, url) print "Opened URL" if permissionFlag: time.sleep(2) print "Looking for Permission Dialog" permission = PermissionDialog(self.marionette) permission.wait_for_permission_dialog_displayed() print "Pressing Share Button" permission.tap_to_confirm_permission() print "Waiting 30 seconds for URL to load" time.sleep(30) self.device.touch_home_button() #homescreen.wait_to_be_displayed() self.data_layer.disable_wifi() print "Disabled wifi" self.device.turn_screen_off() print "" print "Running Test (", test_name, ")" self.runPowerTest(test_name, "Browser", "browser")
def test_unlock_to_emergency_call_screen(self): lock_screen = LockScreen(self.marionette) passcode_pad = lock_screen.unlock_to_passcode_pad() emergency_call = passcode_pad.tap_emergency_call() emergency_call.switch_to_emergency_call_frame() self.assertTrue(emergency_call.is_emergency_dialer_keypad_displayed, 'emergency dialer keypad is not displayed')
def music_playback(self, screen_flag): self.push_resource(os.path.abspath('source/MP3_Au4.mp3')) lock_screen = LockScreen(self.marionette) homescreen = lock_screen.unlock() #self.wait_for_condition(lambda m: self.apps.displayed_app.name == homescreen.name) music_app = Music(self.marionette) music_app.launch() music_app.wait_for_music_tiles_displayed() # switch to songs view list_view = music_app.tap_songs_tab() # check that songs (at least one) are available songs = list_view.media self.assertGreater(len(songs), 0, 'The file could not be found') player_view = songs[0].tap_first_song() play_time = time.strptime('00:10', '%M:%S') self.wait_for_condition(lambda m: player_view.player_elapsed_time >= play_time) # validate playback # self.assertTrue(player_view.is_player_playing(), 'The player is not playing') self.marionette.switch_to_frame() print "" if screen_flag: print "Running Music Test (screen on)" test_name = "music_playback" else: self.device.turn_screen_off() print "Running Music Test (screen off)" test_name = "background_music_playback" self.runPowerTest(test_name, "Music", "music")
def test_lockscreen_notification(self): # the lockscreen should display the carrier name Wait(self.marionette, timeout=30).until(lambda m: self.device.has_mobile_connection) lock_screen = LockScreen(self.marionette) lock_screen.switch_to_frame() self.marionette.execute_script( 'new Notification("%s", {body: "%s"});' % (self._notification_title, self._notification_body)) self.marionette.execute_script( 'new Notification("%s", {body: "%s"});' % (self._notification_title + "_2", self._notification_body + "_2")) self.marionette.execute_script( 'new Notification("%s", {body: "%s"});' % (self._notification_title + "_3", self._notification_body + "_3")) Wait(self.marionette).until( lambda m: len(lock_screen.notifications) == 3) # wait until device is off and turn back on Wait(self.marionette, timeout=20).until(lambda m: not self.device.is_screen_enabled) self.device.turn_screen_on() self.take_screenshot()
def setUp(self): GaiaTestCase.setUp(self) # this time we need it locked! self.lockscreen.lock() self.lock_screen = LockScreen(self.marionette) self.lock_screen.wait_for_lockscreen_handle_visible()
def test_a11y_unlock_to_homescreen(self): lock_screen = LockScreen(self.marionette) homescreen = lock_screen.a11y_click_unlock_button() lock_screen.wait_for_lockscreen_not_visible() self.assertEquals(self.apps.displayed_app.name, homescreen.name) windows = self.marionette.find_element(By.ID, 'windows') self.assertFalse(self.accessibility.is_hidden(windows))
def test_unlock_to_homescreen(self): lock_screen = LockScreen(self.marionette) lock_screen.switch_to_frame() homescreen = lock_screen.unlock() Wait(self.marionette).until( lambda m: self.apps.displayed_app.name == homescreen.name) self.take_screenshot()
def setUp(self): GaiaTestCase.setUp(self) # Turn off geolocation prompt self.apps.set_permission('Camera', 'geolocation', 'deny') # this time we need it locked! self.lockscreen.lock() self.lock_screen = LockScreen(self.marionette)
def test_unlock_to_homescreen_with_passcode(self): """ https://moztrap.mozilla.org/manage/case/1296/ """ lock_screen = LockScreen(self.marionette) lock_screen.switch_to_frame() homescreen = lock_screen.unlock_to_homescreen_using_passcode(self._input_passcode) self.wait_for_condition(lambda m: self.apps.displayed_app.name == homescreen.name)
def test_lock_screen_notification(self): lock_screen = LockScreen(self.marionette) lock_screen.switch_to_frame() self.marionette.execute_script('new Notification("%s", {body: "%s"});' % (self._notification_title, self._notification_body)) self.assertEqual(len(lock_screen.notifications), 1) self.assertTrue(lock_screen.notifications[0].is_visible) self.assertEqual(lock_screen.notifications[0].content, self._notification_body) self.assertEqual(lock_screen.notifications[0].title, self._notification_title)
def test_unlock_to_homescreen_with_passcode(self): """ https://moztrap.mozilla.org/manage/case/1296/ """ lock_screen = LockScreen(self.marionette) lock_screen.switch_to_frame() homescreen = lock_screen.unlock_to_homescreen_using_passcode( self._input_passcode) homescreen.wait_to_be_displayed()
def test_lock_screen_notification(self): lock_screen = LockScreen(self.marionette) lock_screen.switch_to_frame() prev_notifications_length = len(lock_screen.notifications) self.marionette.execute_script('new Notification("%s", {body: "%s"});' % (self._notification_title, self._notification_body)) self.assertEqual(len(lock_screen.notifications), prev_notifications_length + 1) # The last added notification is the first in the notifications array self.assertTrue(lock_screen.notifications[0].is_visible) self.assertEqual(lock_screen.notifications[0].content, self._notification_body) self.assertEqual(lock_screen.notifications[0].title, self._notification_title)
def test_dialer_miss_call_from_known_contact_notification(self): """ https://moztrap.mozilla.org/manage/case/9294/ """ PLIVO_TIMEOUT = 30 self.device.lock() from gaiatest.utils.plivo.plivo_util import PlivoUtil self.plivo = PlivoUtil(self.testvars['plivo']['auth_id'], self.testvars['plivo']['auth_token'], self.testvars['plivo']['phone_number']) self.call_uuid = self.plivo.make_call( to_number=self.testvars['local_phone_numbers'][0].replace('+', ''), timeout=PLIVO_TIMEOUT) call_screen = CallScreen(self.marionette) call_screen.wait_for_incoming_call_with_locked_screen() self.plivo.hangup_call(self.call_uuid) Wait(self.plivo, timeout=PLIVO_TIMEOUT).until( lambda p: p.is_call_completed(self.call_uuid), message="Plivo didn't report the call as completed") self.call_uuid = None lock_screen = LockScreen(self.marionette) lock_screen.switch_to_frame() lock_screen.wait_for_notification() # Check if the screen is turned on self.assertTrue(self.device.is_screen_enabled) # Verify the user sees a missed call notification message # and the known contacts info is shown. self.assertTrue(lock_screen.notifications[0].is_visible) self.assertEqual(lock_screen.notifications[0].title, 'Missed call') self.assertTrue( self.contact.givenName in lock_screen.notifications[0].content) self.device.unlock() system = System(self.marionette) system.wait_for_notification_toaster_not_displayed() # Expand the notification bar system.wait_for_status_bar_displayed() utility_tray = system.open_utility_tray() utility_tray.wait_for_notification_container_displayed() # Verify the user sees the missed call event in the notification center # and the known contacts info is shown. notifications = utility_tray.notifications self.assertEqual(notifications[0].title, 'Missed call') self.assertTrue(self.contact.givenName in notifications[0].content)
def test_a11y_unlock_to_camera(self): lock_screen = LockScreen(self.marionette) camera = lock_screen.a11y_click_camera_button() lock_screen.wait_for_lockscreen_not_visible() self.assertEquals(self.apps.displayed_app.name, camera.name) windows = self.marionette.find_element(By.ID, 'windows') self.assertFalse(self.accessibility.is_hidden(windows)) camera.switch_to_camera_frame() camera.wait_for_capture_ready()
def test_unlock_to_camera(self): # https://moztrap.mozilla.org/manage/case/1296/ lock_screen = LockScreen(self.marionette) camera = lock_screen.unlock_to_camera() lock_screen.wait_for_lockscreen_not_visible() self.assertFalse(self.device.is_locked) # Wait fot the capture button displayed. no need to take a photo. camera.switch_to_camera_frame() camera.wait_for_camera_ready()
def test_unlock_to_homescreen_with_passcode(self): """Unlock device to homescreen when a passcode is set https://github.com/mozilla/gaia-ui-tests/issues/478 """ lock_screen = LockScreen(self.marionette) homescreen = lock_screen.unlock() lock_screen.passcode_pad.type_passcode(self._input_passcode) self.wait_for_condition( lambda m: self.apps.displayed_app.name == homescreen.name)
def test_unlock_to_homescreen_on(self): """https://moztrap.mozilla.org/manage/case/1296/""" lock_screen = LockScreen(self.marionette) homescreen = lock_screen.unlock() #self.wait_for_condition(lambda m: self.apps.displayed_app.name == homescreen.name) #homescreen.wait_to_be_displayed() print "" print "Running Idle Test (screen on)" self.runPowerTest("idle_screen_on", "Homescreen", "verticalhome")
def setUp(self): GaiaTestCase.setUp(self) #set passcode-lock self.data_layer.set_setting('lockscreen.passcode-lock.code', self._input_passcode) self.data_layer.set_setting('lockscreen.passcode-lock.enabled', True) # this time we need it locked! self.lockscreen.lock() self.lock_screen = LockScreen(self.marionette)
def test_unlock_to_emergency_call_screen(self): """Test that emergency call screen can open https://github.com/mozilla/gaia-ui-tests/issues/762 """ lock_screen = LockScreen(self.marionette) lock_screen.unlock() emergency_screen = lock_screen.passcode_pad.tap_emergency_call() self.assertTrue(emergency_screen.is_emergency_dialer_keypad_displayed, 'emergency dialer keypad is not displayed')
def test_unlock_to_homescreen(self): """ https://moztrap.mozilla.org/manage/case/6784/ """ lock_screen = LockScreen(self.marionette) lock_screen.switch_to_frame() homescreen = lock_screen.unlock() self.wait_for_condition( lambda m: self.apps.displayed_app.name == homescreen.name)
def test_lockscreen_time_check(self): """ https: // bugzilla.mozilla.org / show_bug.cgi?id = 1118054 Due to the Bug 1133803, test requires active sim with data connection """ self.settings = Settings(self.marionette) self.settings.launch() datetime_setting = self.settings.open_date_and_time_settings() old_time = datetime_setting.get_current_time_datetime # Auto time update is by default set to true, turn it off to make region change datetime_setting.toggle_automatic_time_update() self.assertFalse(datetime_setting.is_autotime_enabled, 'Autotime still enabled') # change the region. since no one will be in Atlantic Ocean timezone, change in time # will be guaranteed. datetime_setting.set_region('Atlantic Ocean') # get the displayed time after the region change new_time = datetime_setting.get_current_time_datetime self.assertNotEqual(new_time, old_time) # lock screen and check time on the lockscreen self.marionette.switch_to_frame() self.device.lock() lock_screen = LockScreen(self.marionette) difference = lock_screen.time_in_datetime - new_time self.assertLessEqual(difference.seconds, 60) # configure to set the time automatically (this will revert the timezone change), then lock screen lock_screen.switch_to_frame() lock_screen.unlock() self.apps.switch_to_displayed_app() # Enable the auto time update, so the regions change back and date/time is reverted back datetime_setting.toggle_automatic_time_update() self.assertTrue(datetime_setting.is_autotime_enabled, 'Autotime still disabled') self.marionette.switch_to_frame() self.device.lock() # wait until device is off and turn back on to check that the time is changed Wait(self.marionette, timeout=20).until(lambda m: not self.device.is_screen_enabled) self.device.turn_screen_on() self.marionette.switch_to_frame() # Check it reverted to the correct time, and compare it with the previously shown time # Allow 4 minutes difference max difference = lock_screen.time_in_datetime - old_time self.assertLessEqual(difference.seconds, 240)
def test_unlock_to_homescreen(self): """ https://moztrap.mozilla.org/manage/case/6784/ """ lock_screen = LockScreen(self.marionette) lock_screen.switch_to_frame() homescreen = lock_screen.unlock() from gaiatest.apps.homescreen.app import Homescreen Homescreen(self.marionette).wait_to_be_displayed()
def test_lock_screen_notification(self): lock_screen = LockScreen(self.marionette) self.marionette.execute_script( 'navigator.mozNotification.createNotification("%s", "%s").show();' % (self._notification_title, self._notification_body)) self.assertEqual(len(lock_screen.notifications), 1) self.assertTrue(lock_screen.notifications[0].is_visible) self.assertEqual(lock_screen.notifications[0].content, self._notification_body) self.assertEqual(lock_screen.notifications[0].title, self._notification_title)
def setUp(self): GaiaTestCase.setUp(self) # Turn off geolocation prompt self.apps.set_permission('System', 'geolocation', 'deny') self.data_layer.set_setting('lockscreen.passcode-lock.code', self._input_passcode) self.data_layer.set_setting('lockscreen.passcode-lock.enabled', True) # this time we need it locked! self.lockscreen.lock() self.lock_screen = LockScreen(self.marionette) self.lock_screen.wait_for_lockscreen_handle_visible()
def test_unlock_to_camera(self): """https://moztrap.mozilla.org/manage/case/2460/""" lock_screen = LockScreen(self.marionette) lock_screen.switch_to_frame() camera = lock_screen.unlock_to_camera() self.wait_for_condition( lambda m: self.apps.displayed_app.name == camera.name) self.assertFalse(self.device.is_locked) # Wait fot the capture button displayed. no need to take a photo. self.apps.switch_to_displayed_app() camera.wait_for_capture_ready()