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()
class TestLockScreenNotification(GaiaTestCase):
_notification_title = "TestNotificationBar_TITLE"
_notification_body = "TestNotificationBar_BODY"
def test_lock_screen_wake_with_notification(self):
self.lockscreen.lock()
self.lock_screen = LockScreen(self.marionette)
self.device.turn_screen_off()
# Check if the screen is turned off
self.assertFalse(self.device.is_screen_enabled)
self.marionette.execute_script(
'navigator.mozNotification.createNotification("%s", "%s").show();'
% (self._notification_title, self._notification_body)
)
self.lock_screen.wait_for_notification()
# Check if the screen is turned on
self.assertTrue(self.device.is_screen_enabled)
# Check if the notification is displayed on the screen
self.assertTrue(self.lock_screen.notifications[0].is_visible)
self.assertEqual(self.lock_screen.notifications[0].content, self._notification_body)
class TestLockScreen(GaiaTestCase):
_input_passcode = "7931"
# Homescreen locators
_homescreen_frame_locator = (By.CSS_SELECTOR, "div.homescreen iframe")
_homescreen_landing_locator = (By.ID, "icongrid")
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_homescreen_with_passcode(self):
"""Unlock device to homescreen when a passcode is set
https://github.com/mozilla/gaia-ui-tests/issues/478
"""
homescreen = self.lock_screen.unlock()
self.lock_screen.passcode_pad.type_passcode(self._input_passcode)
self.lock_screen.wait_for_lockscreen_not_visible()
homescreen.switch_to_homescreen_frame()
homescreen.wait_for_landing_page_visible()
def test_unlock_to_homescreen_with_passcode(self):
lock_screen = LockScreen(self.marionette)
lock_screen.switch_to_frame()
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 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_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 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")
class TestLockScreen(GaiaTestCase):
_input_passcode = '7931'
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
"""
self.lock_screen.unlock()
emergency_screen = self.lock_screen.passcode_pad.tap_emergency_call()
self.assertTrue(emergency_screen.is_emergency_dialer_keypad_displayed,
'emergency dialer keypad is not displayed')
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_background_music_playback(self):
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:03', '%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()
self.device.turn_screen_off()
print ""
print "Running Music Test (screen off)"
self.runPowerTest("background_music_playback", "Music", "music")
def test_lock_screen_open_sms_notification(self):
lock_screen = LockScreen(self.marionette)
# Check if the screen is turned off
#self.assertFalse(self.device.is_screen_enabled)
_text_message_content = "Automated Test %s" % str(time.time())
system = System(self.marionette)
# Send a SMS to the device
self.data_layer.send_sms(self.testvars['carrier']['phone_number'], _text_message_content)
self.device.lock()
self.device.turn_screen_off()
lock_screen.wait_for_notification()
#Click notification
notifications = self.marionette.find_elements(By.CSS_SELECTOR, '#notifications-lockscreen-container div[class="notification"]')
for no in notifications:
if "Automated Test" in no.text:
no.tap()
open = self.marionette.find_element(By.CSS_SELECTOR, '#notifications-lockscreen-container span[class="button-actionable"]')
open.tap()
break;
self.wait_for_condition(lambda m: self.apps.displayed_app.name == 'Messages')
self.assertEqual(self.apps.displayed_app.name, 'Messages')
class TestCameraUnlockWithPasscode(GaiaTestCase):
# Input data
_input_passcode = '7931'
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_with_passcode(self):
# https://github.com/mozilla/gaia-ui-tests/issues/479
self.lock_screen.swipe_to_unlock()
camera = self.lock_screen.tap_camera_button()
self.assertFalse(camera.is_gallery_button_visible)
camera.tap_switch_source()
camera.wait_for_capture_ready()
self.assertFalse(camera.is_gallery_button_visible)
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 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_camera_video(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)
time.sleep(5)
self.camera.tap_switch_source()
time.sleep(5)
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)
self.camera.tap_capture()
print ""
print "Running Camera Video Test"
self.runPowerTest("camera_video", "Camera", "camera")
self.camera.tap_capture()
def test_unlock_to_emergency_call_screen(self):
lock_screen = LockScreen(self.marionette)
lock_screen.switch_to_frame()
emergency_call = lock_screen.unlock_to_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 test_camera_video(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()
time.sleep(5)
self.camera.tap_switch_source()
time.sleep(5)
self.marionette.switch_to_frame()
self.wait_for_element_present(*self._camera_frame_locator)
camera_frame = self.marionette.find_element(*self._camera_frame_locator)
camera_frame.tap()
self.marionette.switch_to_frame(camera_frame)
self.camera.tap_capture()
print ""
print "Running Camera Video Test"
self.runPowerTest("camera_video", "Camera", "camera")
self.camera.tap_capture()
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 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_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")
class TestLockScreen(GaiaTestCase):
_input_passcode = '7931'
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_homescreen_with_passcode(self):
"""Unlock device to homescreen when a passcode is set
https://github.com/mozilla/gaia-ui-tests/issues/478
"""
homescreen = self.lock_screen.unlock()
self.lock_screen.passcode_pad.type_passcode(self._input_passcode)
self.lock_screen.wait_for_lockscreen_not_visible()
homescreen.switch_to_homescreen_frame()
homescreen.wait_for_homescreen_displayed()
class TestCameraUnlockWithPasscode(GaiaTestCase):
# Input data
_input_passcode = '7931'
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)
def test_unlock_to_camera_with_passcode(self):
# https://github.com/mozilla/gaia-ui-tests/issues/479
camera = self.lock_screen.unlock_to_camera()
self.lock_screen.wait_for_lockscreen_not_visible()
self.assertFalse(self.lockscreen.is_locked)
camera.switch_to_camera_frame()
self.assertFalse(camera.is_gallery_button_visible)
camera.tap_switch_source()
camera.wait_for_capture_ready()
self.assertFalse(camera.is_gallery_button_visible)
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_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()
class TestLockScreen(GaiaTestCase):
_input_passcode = '7931'
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_homescreen_with_passcode(self):
"""Unlock device to homescreen when a passcode is set
https://github.com/mozilla/gaia-ui-tests/issues/478
"""
homescreen = self.lock_screen.unlock()
self.lock_screen.passcode_pad.type_passcode(self._input_passcode)
self.lock_screen.wait_for_lockscreen_not_visible()
homescreen.switch_to_homescreen_frame()
homescreen.wait_for_landing_page_visible()
def test_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_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_emergency_call_screen(self):
lock_screen = LockScreen(self.marionette)
passcode_pad = lock_screen.unlock_to_passcode_pad()
emergency_call = passcode_pad.tap_emergency_call()
if self.device.has_mobile_connection:
emergency_call.switch_to_emergency_call_frame()
self.assertTrue(emergency_call.is_emergency_dialer_keypad_displayed,
'emergency dialer keypad is not displayed')
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 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 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_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_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 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_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_camera(self):
"""https://moztrap.mozilla.org/manage/case/2460/"""
lock_screen = LockScreen(self.marionette)
camera = lock_screen.unlock_to_camera()
self.wait_for_condition(lambda m: not 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()
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_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)
print ""
print "Running Idle Test (screen on)"
self.runPowerTest("idle_screen_on", "Homescreen", "verticalhome")
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)
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_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_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()
lock_screen.switch_to_frame()
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_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_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 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_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 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_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(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_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_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_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 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()
def test_unlock_to_emergency_call_screen(self):
lock_screen = LockScreen(self.marionette)
passcode_pad = lock_screen.unlock_to_passcode_pad()
emergency_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/1296/"""
lock_screen = LockScreen(self.marionette)
homescreen = lock_screen.unlock()
self.wait_for_condition(lambda m: self.apps.displayed_app.name == homescreen.name)
class TestLockScreen(GaiaTestCase):
_input_passcode = '7931'
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
"""
self.lock_screen.unlock()
emergency_screen = self.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_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')
