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()
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()
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_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_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 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_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)
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()
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.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")
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()
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")
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_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_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 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 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_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_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_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):
"""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)
print ""
print "Running Idle Test (screen on)"
self.runPowerTest("idle_screen_on", "Homescreen", "verticalhome")
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_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()
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()
class TestLockScreen(GaiaTestCase):
def setUp(self):
GaiaTestCase.setUp(self)
# this time we need it locked!
self.lockscreen.lock()
self.lock_screen = LockScreen(self.marionette)
def test_unlock_to_homescreen(self):
# https://moztrap.mozilla.org/manage/case/1296/
homescreen = self.lock_screen.unlock()
homescreen.switch_to_homescreen_frame()
class TestLockScreen(GaiaTestCase):
def setUp(self):
GaiaTestCase.setUp(self)
# this time we need it locked!
self.lockscreen.lock()
self.lock_screen = LockScreen(self.marionette)
def test_unlock_to_homescreen(self):
# https://moztrap.mozilla.org/manage/case/1296/
homescreen = self.lock_screen.unlock()
self.wait_for_condition(lambda m: self.apps.displayed_app.name == homescreen.name)
class TestLockScreen(GaiaTestCase):
def setUp(self):
GaiaTestCase.setUp(self)
# this time we need it locked!
self.lockscreen.lock()
self.lock_screen = LockScreen(self.marionette)
def test_unlock_to_homescreen(self):
# https://moztrap.mozilla.org/manage/case/1296/
homescreen = self.lock_screen.unlock()
self.wait_for_condition(
lambda m: self.apps.displayed_app.name == homescreen.name)
def test_wifi_homescreen_on(self):
"""https://moztrap.mozilla.org/manage/case/1296/"""
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.wait_for_condition(lambda m: self.apps.displayed_app.name == homescreen.name)
print ""
print "Running Wifi Idle Test (screen on)"
self.runPowerTest("idle_wifi_screen_on", "Homescreen", "verticalhome")
class TestLockScreen(GaiaTestCase):
def setUp(self):
GaiaTestCase.setUp(self)
# this time we need it locked!
self.lockscreen.lock()
self.lock_screen = LockScreen(self.marionette)
def test_unlock_to_homescreen(self):
# https://moztrap.mozilla.org/manage/case/1296/
homescreen = self.lock_screen.unlock()
self.lock_screen.wait_for_lockscreen_not_visible()
homescreen.switch_to_homescreen_frame()
homescreen.wait_for_landing_page_visible()
def test_wifi_homescreen_on(self):
"""https://moztrap.mozilla.org/manage/case/1296/"""
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.wait_for_condition(
lambda m: self.apps.displayed_app.name == homescreen.name)
print ""
print "Running Wifi Idle Test (screen on)"
self.runPowerTest("idle_wifi_screen_on", "Homescreen", "verticalhome")
def wifi_browser_run_test(self, url, test_name):
"""https://moztrap.mozilla.org/manage/case/1296/"""
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 ""
print "Running Wifi Browser Test (", test_name, ")"
self.runPowerTest(test_name, "Browser", "browser")
def video_playback(self, screen_flag):
self.push_resource(os.path.abspath('source/meetthecubs.webm'))
lock_screen = LockScreen(self.marionette)
homescreen = lock_screen.unlock()
#self.wait_for_condition(lambda m: self.apps.displayed_app.name == homescreen.name)
video_player = VideoPlayer(self.marionette)
video_player.launch()
video_player.wait_for_thumbnails_to_load(1, 'Video files found on device: %s' %self.data_layer.video_files)
# Assert that there is at least one video available
self.assertGreater(video_player.total_video_count, 0)
first_video_name = video_player.first_video_name
self.assertEqual('none', self.data_layer.current_audio_channel)
self.apps.switch_to_displayed_app()
# Click on the first video
fullscreen_video = video_player.tap_first_video_item()
# Video will play automatically
# We'll wait for the controls to clear so we're 'safe' to proceed
time.sleep(2)
# We cannot tap the toolbar so let's just enable it with javascript
fullscreen_video.show_controls()
# The elapsed time > 0:00 denote the video is playing
zero_time = time.strptime('00:00', '%M:%S')
self.assertGreater(fullscreen_video.elapsed_time, zero_time)
# Check the name too. This will only work if the toolbar is visible
self.assertEqual(first_video_name, fullscreen_video.name)
self.assertEqual('content', self.data_layer.current_audio_channel)
print ""
if screen_flag:
print "Running Video Test (screen on)"
test_name = "video_playback"
else:
self.device.turn_screen_off()
print "Running Video Test (screen off)"
test_name = "background_video_playback"
time.sleep(2)
fullscreen_video.tap_play() #when you turn off the screen, video playback pauses...
self.runPowerTest(test_name, "Video", "video")
def test_post_wifi_disable(self):
lock_screen = LockScreen(self.marionette)
homescreen = lock_screen.unlock()
#homescreen.wait_to_be_displayed()
self.data_layer.disable_wifi() # make sure it starts out disabled
self.data_layer.connect_to_wifi()
print "Connected to wifi"
time.sleep(30)
self.data_layer.disable_wifi()
print "Disabled wifi"
self.device.turn_screen_off()
print ""
print "Running Post Wifi Test (screen off)"
self.runPowerTest("post_idle_wifi", "Homescreen", "verticalhome")
def test_post_wifi_disable(self):
lock_screen = LockScreen(self.marionette)
homescreen = lock_screen.unlock()
#homescreen.wait_to_be_displayed()
self.data_layer.disable_wifi() # make sure it starts out disabled
self.data_layer.connect_to_wifi()
print "Connected to wifi"
time.sleep(30)
self.data_layer.disable_wifi()
print "Disabled wifi"
self.device.turn_screen_off()
print ""
print "Running Post Wifi Test (screen off)"
self.runPowerTest("post_idle_wifi", "Homescreen", "verticalhome")
def test_post_bluetooth(self):
lock_screen = LockScreen(self.marionette)
homescreen = lock_screen.unlock()
settings = Settings(self.marionette)
settings.launch()
bluetooth_settings = settings.open_bluetooth()
self.data_layer.bluetooth_disable() # make sure it starts out disabled
self.data_layer.bluetooth_enable()
print "Enabled bluetooth"
time.sleep(20)
# Sometimes the BT device doesn't show up in the list right off. Try and click it,
# if we can't then do an actual search and then try to click it again
print "First Try"
if not bluetooth_settings.tap_device('HC-06'):
print "About to search for devices"
bluetooth_settings.tap_search_for_devices()
time.sleep(1)
print "Second Try"
if not bluetooth_settings.tap_device('HC-06'):
assert False, "Unable to find bluetooth device 'HC-06'..."
keyboard = Keyboard(self.marionette)
#time.sleep(1)
keyboard.send("1234")
keyboard.tap_enter()
time.sleep(35)
print "Attempting to unpair with device"
bluetooth_settings.refresh_root_element()
if bluetooth_settings.tap_device('HC-06'):
print "Confirming unpair"
time.sleep(2)
bluetooth_settings.tap_confirm_unpair_device()
time.sleep(10)
print "Device unpaired"
print "Done sleep, disabling bluetooth"
self.data_layer.bluetooth_disable()
print "Disabled bluetooth"
self.device.turn_screen_off()
print ""
print "Running Post Bluetooth Test"
self.runPowerTest("post_idle_bluetooth", "Settings", "settings")
def test_post_bluetooth(self):
lock_screen = LockScreen(self.marionette)
homescreen = lock_screen.unlock()
settings = Settings(self.marionette)
settings.launch()
bluetooth_settings = settings.open_bluetooth()
self.data_layer.bluetooth_disable() # make sure it starts out disabled
self.data_layer.bluetooth_enable()
print "Enabled bluetooth"
time.sleep(20)
# Sometimes the BT device doesn't show up in the list right off. Try and click it,
# if we can't then do an actual search and then try to click it again
print "First Try"
if not bluetooth_settings.tap_device('HC-06'):
print "About to search for devices"
bluetooth_settings.tap_search_for_devices()
time.sleep(1)
print "Second Try"
if not bluetooth_settings.tap_device('HC-06'):
assert False, "Unable to find bluetooth device 'HC-06'..."
keyboard = Keyboard(self.marionette)
#time.sleep(1)
keyboard.send("1234")
keyboard.tap_enter()
time.sleep(35)
print "Attempting to unpair with device"
bluetooth_settings.refresh_root_element()
if bluetooth_settings.tap_device('HC-06'):
print "Confirming unpair"
time.sleep(2)
bluetooth_settings.tap_confirm_unpair_device()
time.sleep(10)
print "Device unpaired"
print "Done sleep, disabling bluetooth"
self.data_layer.bluetooth_disable()
print "Disabled bluetooth"
self.device.turn_screen_off()
print ""
print "Running Post Bluetooth Test"
self.runPowerTest("post_idle_bluetooth", "Settings", "settings")
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()
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)
print ""
print "Running Camera Picture Test"
self.runPowerTest("camera_picture", "Camera", "camera", PICTURE_INTERVAL_TIME, self.take_picture)
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')
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 video_playback(self, screen_flag):
self.push_resource(os.path.abspath('source/meetthecubs.webm'))
lock_screen = LockScreen(self.marionette)
homescreen = lock_screen.unlock()
self.wait_for_condition(lambda m: self.apps.displayed_app.name == homescreen.name)
video_player = VideoPlayer(self.marionette)
video_player.launch()
video_player.wait_for_thumbnails_to_load(1, 'Video files found on device: %s' %self.data_layer.video_files)
# Assert that there is at least one video available
self.assertGreater(video_player.total_video_count, 0)
first_video_name = video_player.first_video_name
self.assertEqual('none', self.data_layer.current_audio_channel)
self.apps.switch_to_displayed_app()
# Click on the first video
fullscreen_video = video_player.tap_first_video_item()
# Video will play automatically
# We'll wait for the controls to clear so we're 'safe' to proceed
time.sleep(2)
# We cannot tap the toolbar so let's just enable it with javascript
fullscreen_video.show_controls()
# The elapsed time > 0:00 denote the video is playing
zero_time = time.strptime('00:00', '%M:%S')
self.assertGreater(fullscreen_video.elapsed_time, zero_time)
# Check the name too. This will only work if the toolbar is visible
self.assertEqual(first_video_name, fullscreen_video.name)
self.assertEqual('content', self.data_layer.current_audio_channel)
print ""
if screen_flag:
print "Running Video Test (screen on)"
test_name = "video_playback"
else:
self.device.turn_screen_off()
print "Running Video Test (screen off)"
test_name = "background_video_playback"
time.sleep(2)
fullscreen_video.tap_play() #when you turn off the screen, video playback pauses...
self.runPowerTest(test_name, "Video", "video")
