class test_main(GaiaTestCase):
def setUp(self):
GaiaTestCase.setUp(self)
self.UTILS = UTILS(self)
self.browser = Browser(self)
def tearDown(self):
self.UTILS.reporting.reportResults()
GaiaTestCase.tearDown(self)
def test_run(self):
self.UTILS.test.test(not self.UTILS.network.is_network_type_enabled("data"),
"Data mode is disabled before we start this test.")
self.UTILS.statusbar.toggleViaStatusBar("data")
self.wait_for_condition(lambda m: self.data_layer.is_cell_data_connected,
timeout=20, message="Device attached to data connection")
self.browser.launch()
self.browser.open_url("http://www.google.com")
self.UTILS.statusbar.toggleViaStatusBar("data")
self.wait_for_condition(lambda m: not self.data_layer.is_cell_data_connected,
timeout=20, message="Device attached to data connection")
self.UTILS.element.waitForNotElements(DOM.Statusbar.dataConn, "Data icon in statusbar")
class test_main(GaiaTestCase):
def setUp(self):
# Set up child objects...
GaiaTestCase.setUp(self)
self.UTILS = UTILS(self)
self.browser = Browser(self)
self.testURL = self.UTILS.general.get_config_variable("test_url", "common")
self.UTILS.reporting.logComment("Using " + self.testURL)
# switch off keyboard FTU screen
self.data_layer.set_setting("keyboard.ftu.enabled", False)
def tearDown(self):
self.UTILS.reporting.reportResults()
GaiaTestCase.tearDown(self)
def test_run(self):
# Wifi needs to be off for this test to work.
self.data_layer.connect_to_cell_data()
# Open the browser app.
self.browser.launch()
# Open our URL.
self.browser.open_url(self.testURL)
class test_main(GaiaTestCase):
def setUp(self):
# Set up child objects...
GaiaTestCase.setUp(self)
self.UTILS = UTILS(self)
self.settings = Settings(self)
self.browser = Browser(self)
self.url1 = "www.google.com"
self.url2 = "www.wikipedia.org"
def tearDown(self):
self.UTILS.reporting.reportResults()
GaiaTestCase.tearDown(self)
def test_run(self):
# Open the Settings application.
self.connect_to_network()
# Open the browser app.
self.browser.launch()
# Open our URL.
self.browser.open_url(self.url1)
self.marionette.switch_to_frame()
self.browser.wait_for_page_to_load()
self.UTILS.test.test(self.url1 in self.browser.loaded_url(),
"Web page loaded correctly.")
self.browser.open_url(self.url2)
self.marionette.switch_to_frame()
self.browser.wait_for_page_to_load()
self.UTILS.test.test(self.url2 in self.browser.loaded_url(),
"Web page loaded correctly.")
class test_main(GaiaTestCase):
def setUp(self):
GaiaTestCase.setUp(self)
self.UTILS = UTILS(self)
self.browser = Browser(self)
self.settings = Settings(self)
self.download_manager = DownloadManager(self)
self.video = Video(self)
self.test_url = self.UTILS.general.get_config_variable("download_url", "common")
self.file_name = "clipcanvas_14348_H264_320x180.mp4"
self.data_url = "{}/{}".format(self.test_url, self.file_name)
self.connect_to_network()
self.settings.launch()
self.settings.downloads()
self.download_manager.clean_downloads_list()
def tearDown(self):
self.UTILS.reporting.reportResults()
GaiaTestCase.tearDown(self)
def test_run(self):
self.UTILS.statusbar.clearAllStatusBarNotifs()
self.browser.launch()
self.browser.open_url(self.test_url)
self.download_manager.download_file(self.file_name)
self.UTILS.statusbar.wait_for_notification_toaster_title("Download complete", timeout=120)
class test_main(GaiaTestCase):
def setUp(self):
# Set up child objects...
GaiaTestCase.setUp(self)
self.UTILS = UTILS(self)
self.settings = Settings(self)
self.browser = Browser(self)
self.wifi_name = self.UTILS.general.get_config_variable("ssid", "wifi")
self.wifi_pass = self.UTILS.general.get_config_variable("password", "wifi")
self.testURL = self.UTILS.general.get_config_variable("test_url", "common")
self.apps.set_permission_by_url(Browser.search_manifest_url, 'geolocation', 'deny')
# switch off keyboard FTU screen
self.data_layer.set_setting("keyboard.ftu.enabled", False)
def tearDown(self):
self.UTILS.reporting.reportResults()
GaiaTestCase.tearDown(self)
def test_run(self):
# Open the settings application.
self.settings.launch()
# Connect to the wifi.
self.settings.wifi()
self.settings.connect_to_wifi(self.wifi_name, self.wifi_pass)
# Open the browser app.
self.browser.launch()
# Open our URL.
self.browser.open_url(self.testURL)
class test_main(GaiaTestCase):
def setUp(self):
# Set up child objects...
GaiaTestCase.setUp(self)
self.UTILS = UTILS(self)
self.browser = Browser(self)
def tearDown(self):
self.UTILS.reporting.reportResults()
GaiaTestCase.tearDown(self)
def test_run(self):
url1 = "www.google.com"
url2 = "www.bbc.co.uk"
# Wifi needs to be off for this test to work.
self.data_layer.connect_to_cell_data()
# Open the browser app.
self.browser.launch()
# Open our URL.
self.browser.open_url(url1)
self.browser.open_url(url2, timeout=60) # bbc is heavier
class test_main(GaiaTestCase):
def setUp(self):
# Set up child objects...
GaiaTestCase.setUp(self)
self.UTILS = UTILS(self)
self.settings = Settings(self)
self.browser = Browser(self)
self.url1 = "www.google.com"
self.url2 = "www.wikipedia.org"
def tearDown(self):
self.UTILS.reporting.reportResults()
GaiaTestCase.tearDown(self)
def test_run(self):
# Open the Settings application.
self.connect_to_network()
# Open the browser app.
self.browser.launch()
# Open our URL.
self.browser.open_url(self.url1)
self.marionette.switch_to_frame()
self.browser.wait_for_page_to_load()
self.UTILS.test.test(self.url1 in self.browser.loaded_url(), "Web page loaded correctly.")
self.browser.open_url(self.url2)
self.marionette.switch_to_frame()
self.browser.wait_for_page_to_load()
self.UTILS.test.test(self.url2 in self.browser.loaded_url(), "Web page loaded correctly.")
class test_main(GaiaTestCase):
def setUp(self):
# Set up child objects...
GaiaTestCase.setUp(self)
self.UTILS = UTILS(self)
self.browser = Browser(self)
def tearDown(self):
self.UTILS.reporting.reportResults()
GaiaTestCase.tearDown(self)
def test_run(self):
url1 = "www.google.com"
url2 = "www.bbc.co.uk"
# Wifi needs to be off for this test to work.
self.data_layer.connect_to_cell_data()
# Open the browser app.
self.browser.launch()
# Open our URL.
self.browser.open_url(url1)
self.browser.open_url(url2, timeout=60) # bbc is heavier
class test_main(GaiaTestCase):
def setUp(self):
GaiaTestCase.setUp(self)
self.UTILS = UTILS(self)
self.browser = Browser(self)
self.settings = Settings(self)
self.download_manager = DownloadManager(self)
self.test_url = self.UTILS.general.get_config_variable("download_url", "common")
self.file_name = "11MB.rar"
self.data_url = "{}/{}".format(self.test_url, self.file_name)
# make the download process slower
self.data_layer.connect_to_cell_data()
self.settings.launch()
self.settings.downloads()
self.download_manager.clean_downloads_list()
def tearDown(self):
self.UTILS.reporting.reportResults()
GaiaTestCase.tearDown(self)
def test_run(self):
self.UTILS.statusbar.clearAllStatusBarNotifs()
self.browser.launch()
self.browser.open_url(self.test_url)
self.download_manager.download_file(self.file_name)
self.UTILS.statusbar.wait_for_notification_toaster_title(
text="Download started", notif_text="Downloading", timeout=15)
is_there = self.UTILS.statusbar.isIconInStatusBar(DOM.Statusbar.downloads)
self.UTILS.test.test(is_there, "Verify that the download icon in status bar is active")
class test_main(GaiaTestCase):
def setUp(self):
GaiaTestCase.setUp(self)
self.UTILS = UTILS(self)
self.browser = Browser(self)
self.settings = Settings(self)
self.wifi_name = self.UTILS.general.get_config_variable("ssid", "wifi")
self.wifi_pass = self.UTILS.general.get_config_variable("password", "wifi")
self.data_layer.connect_to_wifi()
self.data_layer.is_wifi_connected()
self.apps.kill_all()
self.url = "http://jaoo.github.io/service-worker-testing/index.html"
self.sw_scope = "http://jaoo.es/service-worker-testing/"
self.sw_header = "http://jaoo.es!appId=22&inBrowser=1"
self.script_spec = "http://jaoo.es/service-worker-testing/service.js"
def tearDown(self):
self.data_layer.disable_wifi()
self.UTILS.reporting.reportResults()
GaiaTestCase.tearDown(self)
def test_run(self):
self.browser.launch()
self.browser.open_url(self.url)
register_btn = self.UTILS.element.getElement(dom.register_btn_dom, "Register Worker button")
register_btn.tap()
self.settings.launch()
time.sleep(2)
self.settings.developer_settings()
time.sleep(2)
self.settings.service_workers_menu()
div_dom = (DOM.Settings.service_worker_div[0], DOM.Settings.service_worker_div[1].format(self.sw_scope))
div_elem = self.UTILS.element.getElement(div_dom, "Service worker div")
self.UTILS.element.scroll_into_view(div_elem)
header = div_elem.find_element(*DOM.Settings.service_worker_header)
self.UTILS.test.test(header.text == self.sw_header, "Header found [{}] Expected [{}]".
format(header.text, self.sw_header))
scope = div_elem.find_element(*DOM.Settings.service_worker_scope)
self.UTILS.test.test(self.sw_scope == scope.text, "Scope found [{}] Expected [{}]".
format(scope.text, self.sw_scope))
script_spec = div_elem.find_element(*DOM.Settings.service_worker_script_spec)
self.UTILS.test.test(self.script_spec == script_spec.text, "Script spec found [{}] Expected [{}]".
format(script_spec.text, self.script_spec))
worker_url = div_elem.find_element(*DOM.Settings.service_worker_current_url)
self.UTILS.test.test(self.script_spec == worker_url.text, "URL found [{}] Expected [{}]".
format(worker_url.text, self.script_spec))
unregister_btn = div_elem.find_element(*DOM.Settings.service_worker_unregister_btn)
unregister_btn.tap()
class test_main(GaiaTestCase):
def setUp(self):
GaiaTestCase.setUp(self)
self.UTILS = UTILS(self)
self.browser = Browser(self)
self.settings = Settings(self)
self.wifi_name = self.UTILS.general.get_config_variable("ssid", "wifi")
self.wifi_pass = self.UTILS.general.get_config_variable("password", "wifi")
self.data_layer.connect_to_wifi()
self.data_layer.is_wifi_connected()
self.apps.kill_all()
self.url = "https://acperez.github.io/gecko-sw-test/"
self.sw_scope = "https://acperez.github.io/gecko-sw-test/"
self.sw_header = "https://acperez.github.io!appId=22&inBrowser=1"
self.script_spec = "https://acperez.github.io/gecko-sw-test/service-worker.js"
def tearDown(self):
self.data_layer.disable_wifi()
self.UTILS.reporting.reportResults()
GaiaTestCase.tearDown(self)
def test_run(self):
self.browser.launch()
self.browser.open_url(self.url)
register_btn = self.UTILS.element.getElement(dom.acperez_register_btn_dom, "Register Worker button")
register_btn.tap()
self.settings.launch()
time.sleep(2)
self.settings.developer_settings()
time.sleep(2)
self.settings.service_workers_menu()
div_dom = (DOM.Settings.service_worker_div[0], DOM.Settings.service_worker_div[1].format(self.sw_scope))
div_elem = self.UTILS.element.getElement(div_dom, "Service worker div")
self.UTILS.element.scroll_into_view(div_elem)
header = div_elem.find_element(*DOM.Settings.service_worker_header)
self.UTILS.test.test(header.text == self.sw_header, "Header found [{}] Expected [{}]".
format(header.text, self.sw_header))
scope = div_elem.find_element(*DOM.Settings.service_worker_scope)
self.UTILS.test.test(self.sw_scope == scope.text, "Scope found [{}] Expected [{}]".
format(scope.text, self.sw_scope))
script_spec = div_elem.find_element(*DOM.Settings.service_worker_script_spec)
self.UTILS.test.test(self.script_spec == script_spec.text, "Script spec found [{}] Expected [{}]".
format(script_spec.text, self.script_spec))
worker_url = div_elem.find_element(*DOM.Settings.service_worker_current_url)
self.UTILS.test.test(self.script_spec == worker_url.text, "URL found [{}] Expected [{}]".
format(worker_url.text, self.script_spec))
unregister_btn = div_elem.find_element(*DOM.Settings.service_worker_unregister_btn)
unregister_btn.tap()
class test_main(GaiaTestCase):
button_locator = ('css selector', "button.icon")
def setUp(self):
GaiaTestCase.setUp(self)
self.UTILS = UTILS(self)
self.browser = Browser(self)
self.settings = Settings(self)
self.download_manager = DownloadManager(self)
self.test_url = self.UTILS.general.get_config_variable("download_url", "common")
self.file_name = "clipcanvas_14348_H264_320x180.mp4"
self.data_url = "{}/{}".format(self.test_url, self.file_name)
self.connect_to_network()
self.settings.launch()
self.settings.downloads()
self.download_manager.clean_downloads_list()
self.apps.kill_all()
time.sleep(2)
def tearDown(self):
self.UTILS.reporting.reportResults()
GaiaTestCase.tearDown(self)
def test_run(self):
self.UTILS.statusbar.clearAllStatusBarNotifs()
self.browser.launch()
self.browser.open_url(self.test_url)
self.download_manager.download_file(self.file_name)
self.UTILS.statusbar.wait_for_notification_toaster_title("Download complete", timeout=60)
time.sleep(3)
self.settings.launch()
self.settings.downloads()
self.download_manager.open_download(self.data_url)
share_option = self.UTILS.element.getElement(DOM.DownloadManager.download_file_option_share,
"Getting Share option button")
share_option.tap()
self.marionette.switch_to_frame()
share_menu = self.UTILS.element.getElement(DOM.GLOBAL.action_menu, "Share menu")
options = share_menu.find_elements(*self.button_locator)
self.UTILS.test.test(len(options) > 0, "A list with several options to share is shown")
self._show_option(options)
def _show_option(self, options):
for option in options:
self.UTILS.reporting.logResult('info', "Share option: {}".format(option.text))
class test_main(GaiaTestCase):
def setUp(self):
GaiaTestCase.setUp(self)
self.UTILS = UTILS(self)
self.browser = Browser(self)
self.settings = Settings(self)
self.download_manager = DownloadManager(self)
self.test_url = self.UTILS.general.get_config_variable(
"download_url", "common")
self.file_name = "1GB.rar"
self.data_url = "{}/{}".format(self.test_url, self.file_name)
# make the download process slower
self.data_layer.connect_to_cell_data()
self.settings.launch()
self.settings.downloads()
self.download_manager.clean_downloads_list()
def tearDown(self):
self.UTILS.reporting.reportResults()
GaiaTestCase.tearDown(self)
def test_run(self):
self.UTILS.statusbar.clearAllStatusBarNotifs()
self.browser.launch()
self.browser.open_url(self.test_url)
self.download_manager.download_file(self.file_name)
self.UTILS.statusbar.wait_for_notification_toaster_title(
text="Download started", notif_text="Downloading", timeout=15)
time.sleep(5)
self.apps.kill_all()
time.sleep(2)
self.settings.launch()
self.settings.downloads()
# Verify status downloading using data-state="downloading".
self.download_manager.verify_download_status(self.data_url,
"downloading")
download_info = self.download_manager.get_download_info(self.data_url)
match = re.search(
r"(\d)+(.(\d)+)*\s(GB|MB|KB)\sof\s(\d)+(.(\d)+)*\sGB$",
download_info.text)
self.UTILS.test.test(match is not None,
"Verify the the text is: 'X' GB of 'Y' GB")
time.sleep(3)
self.download_manager.stop_download(self.data_url, True)
class test_main(GaiaTestCase):
def setUp(self):
GaiaTestCase.setUp(self)
self.UTILS = UTILS(self)
self.browser = Browser(self)
self.settings = Settings(self)
self.download_manager = DownloadManager(self)
self.test_url = self.UTILS.general.get_config_variable(
"download_url", "common")
self.file_name = "Crazy_Horse.jpg"
self.data_url = "{}/{}".format(self.test_url, self.file_name)
self.connect_to_network()
self.settings.launch()
self.settings.downloads()
self.download_manager.clean_downloads_list()
def tearDown(self):
self.UTILS.reporting.reportResults()
GaiaTestCase.tearDown(self)
def test_run(self):
self.UTILS.statusbar.clearAllStatusBarNotifs()
self.browser.launch()
self.browser.open_url(self.test_url)
self.download_manager.download_file(self.file_name)
self.UTILS.statusbar.wait_for_notification_toaster_title(
"Download complete", timeout=60)
time.sleep(5)
self.apps.kill_all()
time.sleep(2)
self.settings.launch()
self.settings.downloads()
self.download_manager.open_download(self.data_url)
self.download_manager.tap_on_open_option()
# Verify that the image is opened.
self.UTILS.iframe.switchToFrame(*DOM.Gallery.frame_locator)
title = self.UTILS.element.getElement(DOM.Gallery.file_name_header,
"File name header")
self.UTILS.test.test(title.text == self.file_name,
"File name matches in Gallery")
is_loaded = self.UTILS.element.waitForElements(
DOM.Gallery.current_image_pic, "Waiting for image to be loaded")
self.UTILS.test.test(is_loaded, "Image has been loaded")
class test_main(GaiaTestCase):
test_url = "http://everlong.org/mozilla/packaged/"
_appName = "cool packaged app"
_appOK = True
install_button_locator = ('id', 'install-app')
confirm_install_locator = ('id', 'app-install-install-button')
def setUp(self):
GaiaTestCase.setUp(self)
self.UTILS = UTILS(self)
self.browser = Browser(self)
self.connect_to_network()
# Uninstall the app (if need be).
self.UTILS.app.uninstallApp(self._appName)
def tearDown(self):
self.UTILS.reporting.reportResults()
GaiaTestCase.tearDown(self)
def test_run(self):
self.browser.launch()
self.browser.open_url(self.test_url)
# Install the app (this is a 'one-off' thing, so just keep the DOM spec here).
install_btn = self.UTILS.element.getElement(
self.install_button_locator, "Install an app button")
install_btn.tap()
# Install button on the splash screen (switch to main frame to 'see' this).
self.marionette.switch_to_frame()
install_btn = self.UTILS.element.getElement(
self.confirm_install_locator, "Install button", True, 30)
install_btn.tap()
ok_btn = self.UTILS.element.getElement(
DOM.GLOBAL.modal_dialog_alert_ok, "Ok button")
time.sleep(1)
ok_btn.tap()
expected_msg = "{} installed".format(self._appName)
system_banner = self.UTILS.element.getElement(
DOM.GLOBAL.system_banner, "System notification banner")
self.UTILS.test.test(system_banner.text == expected_msg,
"Banner matches expected message")
# Remove the app.
self.apps.kill_all()
time.sleep(2)
self.UTILS.app.uninstallApp(self._appName)
class test_main(GaiaTestCase):
test_url = "http://everlong.org/mozilla/packaged/"
_appName = "cool packaged app"
_appOK = True
install_button_locator = ('id', 'install-app')
confirm_install_locator = ('id', 'app-install-install-button')
def setUp(self):
# Set up child objects...
GaiaTestCase.setUp(self)
self.UTILS = UTILS(self)
self.settings = Settings(self)
self.browser = Browser(self)
self.connect_to_network()
# Uninstall the app (if need be).
self.UTILS.app.uninstallApp(self._appName)
def tearDown(self):
self.UTILS.reporting.reportResults()
GaiaTestCase.tearDown(self)
def test_run(self):
self.browser.launch()
self.browser.open_url(self.test_url)
"""
Install the app (these DOM items are peculiar to this little dev app,
so dont bother putting them in the main DOM.py file).
"""
install_btn = self.UTILS.element.getElement(self.install_button_locator, "Install an app button")
install_btn.tap()
# Install button on the splash screen (switch to main frame to 'see' this).
self.marionette.switch_to_frame()
install_btn = self.UTILS.element.getElement(self.confirm_install_locator, "Install button", True, 30)
install_btn.tap()
ok_btn = self.UTILS.element.getElement(DOM.GLOBAL.modal_dialog_alert_ok, "Ok button")
ok_btn.tap()
expected_msg = "{} installed".format(self._appName)
system_banner = self.UTILS.element.getElement(DOM.GLOBAL.system_banner, "System notification banner")
self.UTILS.test.test(system_banner.text == expected_msg, "Banner matches expected message")
self.apps.kill_all()
time.sleep(2)
# Go back to the home page and check the app is installed.
self.UTILS.test.test(self.UTILS.app.launchAppViaHomescreen(self._appName),
"Application '" + self._appName + "' can be launched from the homescreen.", True)
class test_main(GaiaTestCase):
def setUp(self):
GaiaTestCase.setUp(self)
self.UTILS = UTILS(self)
self.browser = Browser(self)
self.settings = Settings(self)
self.download_manager = DownloadManager(self)
self.music = Music(self)
self.test_url = self.UTILS.general.get_config_variable(
"download_url", "common")
self.file_name = "GOSPEL.mp3"
self.data_url = "{}/{}".format(self.test_url, self.file_name)
self.connect_to_network()
self.settings.launch()
self.settings.downloads()
self.download_manager.clean_downloads_list()
def tearDown(self):
self.UTILS.reporting.reportResults()
GaiaTestCase.tearDown(self)
def test_run(self):
self.browser.launch()
self.browser.open_url(self.test_url)
self.download_manager.download_file(self.file_name)
self.UTILS.statusbar.wait_for_notification_toaster_title(
"Download complete", timeout=60)
time.sleep(5)
self.apps.kill_all()
time.sleep(2)
self.settings.launch()
self.settings.downloads()
self.download_manager.open_download(self.data_url)
self.download_manager.tap_on_open_option()
self.UTILS.iframe.switchToFrame(*DOM.Music.frame_locator)
time.sleep(5)
title = self.UTILS.element.getElement(
DOM.Music.title_song, "Getting song title in music player")
self.UTILS.test.test(title.text in self.file_name, "Mp3 file title")
self.UTILS.test.test(self.music.is_player_playing(),
"Mp3 file is being played")
class test_main(GaiaTestCase):
def setUp(self):
GaiaTestCase.setUp(self)
self.UTILS = UTILS(self)
self.browser = Browser(self)
self.settings = Settings(self)
self.download_manager = DownloadManager(self)
self.test_url = self.UTILS.general.get_config_variable("download_url", "common")
self.file_name = "41MB.rar"
self.data_url = "{}/{}".format(self.test_url, self.file_name)
self.data_layer.connect_to_cell_data()
self.settings.launch()
self.settings.downloads()
self.download_manager.clean_downloads_list()
def tearDown(self):
self.UTILS.reporting.reportResults()
GaiaTestCase.tearDown(self)
def test_run(self):
self.UTILS.statusbar.clearAllStatusBarNotifs()
self.browser.launch()
self.browser.open_url(self.test_url)
self.download_manager.download_file(self.file_name)
self.UTILS.statusbar.wait_for_notification_toaster_title(text="Download started", notif_text="Downloading", timeout=15)
self.apps.kill_all()
time.sleep(2)
self.settings.launch()
self.settings.downloads()
# Verify status downloading using data-state="downloading".
self.download_manager.verify_download_status(self.data_url, "downloading")
self.download_manager.verify_download_graphical_status(self.data_url, "downloading")
self.UTILS.home.touchHomeButton()
self.UTILS.statusbar.displayStatusBar()
self.UTILS.statusbar.wait_for_notification_statusbar_title("Downloading")
self.UTILS.statusbar.hideStatusBar()
self.UTILS.statusbar.wait_for_notification_toaster_title("Download complete", timeout=240)
class test_main(GaiaTestCase):
def setUp(self):
GaiaTestCase.setUp(self)
self.UTILS = UTILS(self)
self.browser = Browser(self)
self.settings = Settings(self)
self.download_manager = DownloadManager(self)
self.test_url = self.UTILS.general.get_config_variable("download_url", "common")
self.file_name = "11MB.rar"
self.data_url = "{}/{}".format(self.test_url, self.file_name)
self.connect_to_network()
self.settings.launch()
self.settings.downloads()
self.download_manager.clean_downloads_list()
def tearDown(self):
self.UTILS.reporting.reportResults()
GaiaTestCase.tearDown(self)
def test_run(self):
self.browser.launch()
self.browser.open_url(self.test_url)
self.download_manager.download_file(self.file_name)
self.UTILS.statusbar.wait_for_notification_toaster_title("Download complete", timeout=60)
time.sleep(5)
self.apps.kill_all()
time.sleep(2)
previous_number_of_pictures = len(self.data_layer.sdcard_files())
self.settings.launch()
self.settings.downloads()
self.download_manager.open_download(self.data_url)
self.download_manager.open_download_delete_file()
elem = (DOM.DownloadManager.download_element[0],
DOM.DownloadManager.download_element[1].format(self.data_url))
self.UTILS.element.waitForNotElements(elem, "Download is not there")
# Check that picture saved to SD card
self.wait_for_condition(
lambda m: len(self.data_layer.sdcard_files()) == previous_number_of_pictures - 1, 20)
self.assertEqual(len(self.data_layer.sdcard_files()), previous_number_of_pictures - 1)
class test_main(GaiaTestCase):
def setUp(self):
GaiaTestCase.setUp(self)
self.UTILS = UTILS(self)
self.browser = Browser(self)
self.settings = Settings(self)
self.download_manager = DownloadManager(self)
self.test_url = self.UTILS.general.get_config_variable(
"download_url", "common")
self.file_name = "105MB.rar"
self.data_url = "{}/{}".format(self.test_url, self.file_name)
# make the download process slower
self.data_layer.connect_to_cell_data()
self.settings.launch()
self.settings.downloads()
self.download_manager.clean_downloads_list()
def tearDown(self):
self.UTILS.reporting.reportResults()
GaiaTestCase.tearDown(self)
def test_run(self):
self.UTILS.statusbar.clearAllStatusBarNotifs()
self.browser.launch()
self.browser.open_url(self.test_url)
self.download_manager.download_file(self.file_name)
self.UTILS.statusbar.wait_for_notification_toaster_title(
text="Download started", notif_text="Downloading", timeout=15)
time.sleep(5)
self.apps.kill_all()
time.sleep(2)
self.settings.launch()
self.settings.downloads()
# Verify status downloading using data-state="downloading".
self.download_manager.verify_download_status(self.data_url,
"downloading")
self.download_manager.verify_download_graphical_status(
self.data_url, "downloading")
self.download_manager.stop_download(self.data_url, True)
self.UTILS.statusbar.wait_for_notification_statusbar_title(
"Download stopped")
class test_main(GaiaTestCase):
def setUp(self):
GaiaTestCase.setUp(self)
self.UTILS = UTILS(self)
self.browser = Browser(self)
self.settings = Settings(self)
self.download_manager = DownloadManager(self)
self.test_url = self.UTILS.general.get_config_variable(
"download_url", "common")
self.file_name = "prueba_archivo_con_nombre_muy_largo_de_30MB.rar"
self.data_url = "{}/{}".format(self.test_url, self.file_name)
self.connect_to_network()
self.settings.launch()
self.settings.downloads()
self.download_manager.clean_downloads_list()
def tearDown(self):
self.UTILS.reporting.reportResults()
GaiaTestCase.tearDown(self)
def test_run(self):
self.UTILS.statusbar.clearAllStatusBarNotifs()
self.browser.launch()
self.browser.open_url(self.test_url)
self.download_manager.download_file(self.file_name)
self.UTILS.statusbar.wait_for_notification_toaster_title(
"Download complete", timeout=60)
time.sleep(5)
self.apps.kill_all()
time.sleep(2)
self.settings.launch()
self.settings.downloads()
# Check the file is there
entry_name = self.download_manager.get_download_entry(
self.data_url).find_element(*('css selector', 'p.fileName'))
value = self.UTILS.element.get_css_value(entry_name, "text-overflow")
is_ellipsis = self.UTILS.element.is_ellipsis_active(entry_name)
self.UTILS.test.test(
value == "ellipsis" and is_ellipsis,
"Download list shows ellipsis(...) for a long entry [{}]".format(
self.file_name))
class test_main(GaiaTestCase):
def setUp(self):
GaiaTestCase.setUp(self)
self.UTILS = UTILS(self)
self.browser = Browser(self)
self.settings = Settings(self)
self.download_manager = DownloadManager(self)
self.test_url = self.UTILS.general.get_config_variable("download_url", "common")
self.file_name = "1GB.rar"
self.data_url = "{}/{}".format(self.test_url, self.file_name)
# make the download process slower
self.data_layer.connect_to_cell_data()
self.settings.launch()
self.settings.downloads()
self.download_manager.clean_downloads_list()
def tearDown(self):
self.UTILS.reporting.reportResults()
GaiaTestCase.tearDown(self)
def test_run(self):
self.UTILS.statusbar.clearAllStatusBarNotifs()
self.browser.launch()
self.browser.open_url(self.test_url)
self.download_manager.download_file(self.file_name)
self.UTILS.statusbar.wait_for_notification_toaster_title(text="Download started", notif_text="Downloading",
timeout=15)
time.sleep(5)
self.apps.kill_all()
time.sleep(2)
self.settings.launch()
self.settings.downloads()
# Verify status downloading using data-state="downloading".
self.download_manager.verify_download_status(self.data_url, "downloading")
download_info = self.download_manager.get_download_info(self.data_url)
match = re.search(r"(\d)+(.(\d)+)*\s(GB|MB|KB)\sof\s(\d)+(.(\d)+)*\sGB$", download_info.text)
self.UTILS.test.test(match is not None, "Verify the the text is: 'X' GB of 'Y' GB")
time.sleep(3)
self.download_manager.stop_download(self.data_url, True)
class test_main(GaiaTestCase):
def setUp(self):
GaiaTestCase.setUp(self)
self.UTILS = UTILS(self)
self.browser = Browser(self)
self.settings = Settings(self)
self.download_manager = DownloadManager(self)
self.test_url = self.UTILS.general.get_config_variable("download_url", "common")
self.file_name = "105MB.rar"
self.data_url = "{}/{}".format(self.test_url, self.file_name)
# make the download process slower
self.data_layer.connect_to_cell_data()
self.settings.launch()
self.settings.downloads()
self.download_manager.clean_downloads_list()
def tearDown(self):
self.UTILS.reporting.reportResults()
GaiaTestCase.tearDown(self)
def test_run(self):
self.UTILS.statusbar.clearAllStatusBarNotifs()
self.browser.launch()
self.browser.open_url(self.test_url)
self.download_manager.download_file(self.file_name)
self.UTILS.statusbar.wait_for_notification_toaster_title(text="Download started", notif_text="Downloading", timeout=15)
time.sleep(5)
self.apps.kill_all()
time.sleep(2)
self.settings.launch()
self.settings.downloads()
# Verify status downloading using data-state="downloading".
self.download_manager.verify_download_status(self.data_url, "downloading")
self.download_manager.verify_download_graphical_status(self.data_url, "downloading")
self.download_manager.stop_download(self.data_url, True)
is_there = self.UTILS.statusbar.isIconInStatusBar(DOM.Statusbar.downloads)
self.UTILS.test.test(not is_there, "Verify that the download icon in status bar is dismissed")
class test_main(GaiaTestCase):
def setUp(self):
GaiaTestCase.setUp(self)
self.UTILS = UTILS(self)
self.browser = Browser(self)
self.settings = Settings(self)
self.download_manager = DownloadManager(self)
self.test_url = self.UTILS.general.get_config_variable("download_url", "common")
self.file_name = "Crazy_Horse.jpg"
self.data_url = "{}/{}".format(self.test_url, self.file_name)
self.connect_to_network()
self.settings.launch()
self.settings.downloads()
self.download_manager.clean_downloads_list()
def tearDown(self):
self.UTILS.reporting.reportResults()
GaiaTestCase.tearDown(self)
def test_run(self):
self.UTILS.statusbar.clearAllStatusBarNotifs()
self.browser.launch()
self.browser.open_url(self.test_url)
self.download_manager.download_file(self.file_name)
self.UTILS.statusbar.wait_for_notification_toaster_title("Download complete", timeout=60)
time.sleep(5)
self.apps.kill_all()
time.sleep(2)
self.settings.launch()
self.settings.downloads()
self.download_manager.open_download(self.data_url)
self.download_manager.tap_on_open_option()
# Verify that the image is opened.
self.UTILS.iframe.switchToFrame(*DOM.Gallery.frame_locator)
title = self.UTILS.element.getElement(DOM.Gallery.file_name_header, "File name header")
self.UTILS.test.test(title.text == self.file_name, "File name matches in Gallery")
is_loaded = self.UTILS.element.waitForElements(DOM.Gallery.current_image_pic,
"Waiting for image to be loaded")
self.UTILS.test.test(is_loaded, "Image has been loaded")
class test_main(GaiaTestCase):
def setUp(self):
GaiaTestCase.setUp(self)
self.UTILS = UTILS(self)
# Specific for this test.
self.browser = Browser(self)
self.settings = Settings(self)
self.download_manager = DownloadManager(self)
self.testURL = self.UTILS.general.get_config_variable("download_url", "common")
self.file_names = ["Toast.doc", "Porridge.doc"]
self.connect_to_network()
self.settings.launch()
self.settings.downloads()
self.download_manager.clean_downloads_list()
self.apps.kill_all()
time.sleep(2)
def tearDown(self):
self.UTILS.reporting.reportResults()
GaiaTestCase.tearDown(self)
def test_run(self):
self.UTILS.statusbar.clearAllStatusBarNotifs()
self.browser.launch()
self.browser.open_url(self.testURL)
map(self.download_manager.download_file, self.file_names)
self.UTILS.statusbar.wait_for_notification_toaster_title("Download complete", timeout=60)
time.sleep(5)
previous_number_of_pictures = len(self.data_layer.sdcard_files())
self.settings.launch()
self.settings.downloads()
# Delete All downloads
self.download_manager.delete_all_downloads()
# Check that picture saved to SD card
self.wait_for_condition(
lambda m: len(self.data_layer.sdcard_files()) == previous_number_of_pictures - len(self.file_names), 20)
self.assertEqual(len(self.data_layer.sdcard_files()), previous_number_of_pictures - len(self.file_names))
class test_main(GaiaTestCase):
def setUp(self):
GaiaTestCase.setUp(self)
self.UTILS = UTILS(self)
self.browser = Browser(self)
self.settings = Settings(self)
self.download_manager = DownloadManager(self)
self.music = Music(self)
self.test_url = self.UTILS.general.get_config_variable("download_url", "common")
self.file_name = "GOSPEL.mp3"
self.data_url = "{}/{}".format(self.test_url, self.file_name)
self.connect_to_network()
self.settings.launch()
self.settings.downloads()
self.download_manager.clean_downloads_list()
def tearDown(self):
self.UTILS.reporting.reportResults()
GaiaTestCase.tearDown(self)
def test_run(self):
self.browser.launch()
self.browser.open_url(self.test_url)
self.download_manager.download_file(self.file_name)
self.UTILS.statusbar.wait_for_notification_toaster_title("Download complete", timeout=60)
time.sleep(5)
self.apps.kill_all()
time.sleep(2)
self.settings.launch()
self.settings.downloads()
self.download_manager.open_download(self.data_url)
self.download_manager.tap_on_open_option()
self.UTILS.iframe.switchToFrame(*DOM.Music.frame_locator)
time.sleep(5)
title = self.UTILS.element.getElement(DOM.Music.title_song, "Getting song title in music player")
self.UTILS.test.test(title.text in self.file_name, "Mp3 file title")
self.UTILS.test.test(self.music.is_player_playing(), "Mp3 file is being played")
class test_main(GaiaTestCase):
def setUp(self):
GaiaTestCase.setUp(self)
self.UTILS = UTILS(self)
self.browser = Browser(self)
self.settings = Settings(self)
self.download_manager = DownloadManager(self)
self.test_url = self.UTILS.general.get_config_variable("download_url", "common")
self.file_name = "GOSPEL.mp3"
self.data_url = "{}/{}".format(self.test_url, self.file_name)
self.connect_to_network()
self.UTILS.statusbar.clearAllStatusBarNotifs()
# Download and audio file
self.settings.launch()
self.settings.downloads()
self.download_manager.clean_downloads_list()
self.browser.launch()
self.browser.open_url(self.test_url)
self.download_manager.download_file(self.file_name)
self.UTILS.statusbar.wait_for_notification_toaster_title("Download complete", timeout=60)
self.apps.kill_all()
time.sleep(2)
def tearDown(self):
self.UTILS.reporting.reportResults()
GaiaTestCase.tearDown(self)
def test_run(self):
self.settings.launch()
self.settings.downloads()
self.download_manager.open_download(self.data_url)
cancel_btn = self.UTILS.element.getElement(DOM.DownloadManager.download_file_option_cancel,
"Getting Open file button")
cancel_btn.tap()
self.UTILS.element.waitForElements(DOM.Settings.downloads_header,
"Downloads header appears.", True, 20, True)
class test_main(GaiaTestCase):
def setUp(self):
# Set up child objects...
GaiaTestCase.setUp(self)
self.UTILS = UTILS(self)
self.settings = Settings(self)
self.browser = Browser(self)
self.messages = Messages(self)
self.num = self.UTILS.general.get_config_variable(
"phone_number", "custom")
self.cp_incoming_number = self.UTILS.general.get_config_variable(
"sms_platform_numbers", "common").split(',')
self.data_layer.delete_all_sms()
self.url1 = "www.google.com"
self.url2 = "www.wikipedia.org"
def tearDown(self):
self.UTILS.reporting.reportResults()
GaiaTestCase.tearDown(self)
def test_run(self):
self.data_layer.connect_to_wifi()
# Open the browser app.
self.browser.launch()
# Open our URL.
self.browser.open_url(self.url1)
test_msg = "This is a test message sent at {} while connected to a wifi".format(
time.time())
self.UTILS.messages.create_incoming_sms(self.num, test_msg)
self.UTILS.statusbar.wait_for_notification_toaster_detail(test_msg,
timeout=120)
self.UTILS.statusbar.click_on_notification_detail(
test_msg, DOM.Messages.frame_locator)
self.messages.check_last_message_contents(test_msg)
self.browser.launch()
self.browser.open_url(self.url2)
self.marionette.switch_to_frame()
self.browser.wait_for_page_to_load()
self.UTILS.test.test(self.url2 in self.browser.loaded_url(),
"Web page loaded correctly.")
class test_main(GaiaTestCase):
def setUp(self):
GaiaTestCase.setUp(self)
self.UTILS = UTILS(self)
self.browser = Browser(self)
self.settings = Settings(self)
self.download_manager = DownloadManager(self)
self.test_url = self.UTILS.general.get_config_variable("download_url", "common")
self.file_name = "prueba_archivo_con_nombre_muy_largo_de_30MB.rar"
self.data_url = "{}/{}".format(self.test_url, self.file_name)
self.connect_to_network()
self.settings.launch()
self.settings.downloads()
self.download_manager.clean_downloads_list()
def tearDown(self):
self.UTILS.reporting.reportResults()
GaiaTestCase.tearDown(self)
def test_run(self):
self.UTILS.statusbar.clearAllStatusBarNotifs()
self.browser.launch()
self.browser.open_url(self.test_url)
self.download_manager.download_file(self.file_name)
self.UTILS.statusbar.wait_for_notification_toaster_title("Download complete", timeout=60)
time.sleep(5)
self.apps.kill_all()
time.sleep(2)
self.settings.launch()
self.settings.downloads()
# Check the file is there
entry_name = self.download_manager.get_download_entry(self.data_url).find_element(*('css selector', 'p.fileName'))
value = self.UTILS.element.get_css_value(entry_name, "text-overflow")
is_ellipsis = self.UTILS.element.is_ellipsis_active(entry_name)
self.UTILS.test.test(value == "ellipsis" and is_ellipsis,
"Download list shows ellipsis(...) for a long entry [{}]".format(self.file_name))
class test_main(GaiaTestCase):
def setUp(self):
GaiaTestCase.setUp(self)
self.UTILS = UTILS(self)
self.browser = Browser(self)
self.settings = Settings(self)
self.download_manager = DownloadManager(self)
self.video = Video(self)
self.test_url = self.UTILS.general.get_config_variable("download_url", "common")
self.file_name = "clipcanvas_14348_H264_320x180.mp4"
self.data_url = "{}/{}".format(self.test_url, self.file_name)
self.connect_to_network()
self.settings.launch()
self.settings.downloads()
self.download_manager.clean_downloads_list()
def tearDown(self):
self.UTILS.reporting.reportResults()
GaiaTestCase.tearDown(self)
def test_run(self):
self.UTILS.statusbar.clearAllStatusBarNotifs()
self.browser.launch()
self.browser.open_url(self.test_url)
self.download_manager.download_file(self.file_name)
self.UTILS.statusbar.wait_for_notification_toaster_title("Download complete", timeout=60)
time.sleep(5)
self.apps.kill_all()
time.sleep(2)
self.settings.launch()
self.settings.downloads()
self.download_manager.open_download(self.data_url)
self.download_manager.tap_on_open_option()
# Verifying video player
self.UTILS.iframe.switchToFrame(*DOM.Video.frame_locator)
result = self.video.is_this_video_being_played(self.file_name)
self.UTILS.test.test(result, "This video [{}] is actually being played".format(self.file_name))
class test_main(GaiaTestCase):
def setUp(self):
# Set up child objects...
GaiaTestCase.setUp(self)
self.UTILS = UTILS(self)
self.settings = Settings(self)
self.browser = Browser(self)
self.messages = Messages(self)
self.num = self.UTILS.general.get_config_variable(
"phone_number", "custom")
self.url1 = "www.google.com"
self.url2 = "www.wikipedia.org"
self.test_msg = "Test message"
def tearDown(self):
self.UTILS.reporting.reportResults()
GaiaTestCase.tearDown(self)
def test_run(self):
self.data_layer.connect_to_wifi()
# Open the first url
self.browser.launch()
self.browser.open_url(self.url1)
self.marionette.switch_to_frame()
self.browser.wait_for_page_to_load()
self.UTILS.test.test(self.url1 in self.browser.loaded_url(),
"Web page loaded correctly.")
# Open the SMS app, send a message then jump back to the browser.
self.messages.launch()
self.messages.create_and_send_sms([self.num], self.test_msg)
send_time = self.messages.last_sent_message_timestamp()
self.messages.wait_for_message(send_time)
self.apps.kill_all()
time.sleep(2)
self.browser.launch()
self.browser.open_url(self.url2)
self.marionette.switch_to_frame()
self.browser.wait_for_page_to_load()
self.UTILS.test.test(self.url2 in self.browser.loaded_url(),
"Web page loaded correctly.")
class test_main(GaiaTestCase):
def setUp(self):
GaiaTestCase.setUp(self)
self.UTILS = UTILS(self)
# Specific for this test.
self.browser = Browser(self)
self.settings = Settings(self)
self.download_manager = DownloadManager(self)
self.test_url = self.UTILS.general.get_config_variable(
"download_url", "common")
self.file_name = "Crazy_Horse.jpg"
self.data_url = "{}/{}".format(self.test_url, self.file_name)
self.connect_to_network()
self.settings.launch()
self.settings.downloads()
self.download_manager.clean_downloads_list()
self.apps.kill_all()
time.sleep(2)
def tearDown(self):
self.UTILS.reporting.reportResults()
GaiaTestCase.tearDown(self)
def test_run(self):
self.UTILS.statusbar.clearAllStatusBarNotifs()
self.browser.launch()
self.browser.open_url(self.test_url)
self.download_manager.download_file(self.file_name)
self.UTILS.statusbar.wait_for_notification_toaster_title(
"Download complete", timeout=60)
time.sleep(5)
self.settings.launch()
self.settings.downloads()
self.download_manager.verify_download_status(self.data_url,
"succeeded")
self.download_manager.delete_download(self.data_url)
class test_main(GaiaTestCase):
def setUp(self):
GaiaTestCase.setUp(self)
self.UTILS = UTILS(self)
self.browser = Browser(self)
self.settings = Settings(self)
self.download_manager = DownloadManager(self)
self.test_url = self.UTILS.general.get_config_variable(
"download_url", "common")
self.file_name = "11MB.rar"
self.data_url = "{}/{}".format(self.test_url, self.file_name)
self.connect_to_network()
self.settings.launch()
self.settings.downloads()
self.download_manager.clean_downloads_list()
def tearDown(self):
self.UTILS.reporting.reportResults()
GaiaTestCase.tearDown(self)
def test_run(self):
self.browser.launch()
self.browser.open_url(self.test_url)
self.download_manager.download_file(self.file_name)
self.UTILS.statusbar.wait_for_notification_toaster_title(
"Download complete", timeout=60)
time.sleep(5)
self.apps.kill_all()
time.sleep(2)
self.settings.launch()
self.settings.downloads()
self.download_manager.open_download(self.data_url)
self.download_manager.open_download_keep_file()
elem = (DOM.DownloadManager.download_element[0],
DOM.DownloadManager.download_element[1].format(self.data_url))
self.UTILS.element.waitForElements(elem, "Download is still there")
class test_main(GaiaTestCase):
def setUp(self):
GaiaTestCase.setUp(self)
self.UTILS = UTILS(self)
self.browser = Browser(self)
self.settings = Settings(self)
self.download_manager = DownloadManager(self)
self.test_url = self.UTILS.general.get_config_variable("download_url", "common")
self.file_name = "11MB.rar"
self.data_url = "{}/{}".format(self.test_url, self.file_name)
self.connect_to_network()
self.settings.launch()
self.settings.downloads()
self.download_manager.clean_downloads_list()
def tearDown(self):
self.UTILS.reporting.reportResults()
GaiaTestCase.tearDown(self)
def test_run(self):
self.browser.launch()
self.browser.open_url(self.test_url)
self.download_manager.download_file(self.file_name)
self.UTILS.statusbar.wait_for_notification_toaster_title("Download complete", timeout=60)
time.sleep(5)
self.apps.kill_all()
time.sleep(2)
self.settings.launch()
self.settings.downloads()
self.download_manager.open_download(self.data_url)
self.download_manager.open_download_keep_file()
elem = (DOM.DownloadManager.download_element[0],
DOM.DownloadManager.download_element[1].format(self.data_url))
self.UTILS.element.waitForElements(elem, "Download is still there")
class test_main(GaiaTestCase):
def setUp(self):
# Set up child objects...
GaiaTestCase.setUp(self)
self.UTILS = UTILS(self)
self.settings = Settings(self)
self.browser = Browser(self)
self.messages = Messages(self)
self.num = self.UTILS.general.get_config_variable("phone_number", "custom")
self.url1 = "www.google.com"
self.url2 = "www.wikipedia.org"
self.test_msg = "Test message"
def tearDown(self):
self.UTILS.reporting.reportResults()
GaiaTestCase.tearDown(self)
def test_run(self):
self.data_layer.connect_to_wifi()
# Open the first url
self.browser.launch()
self.browser.open_url(self.url1)
self.marionette.switch_to_frame()
self.browser.wait_for_page_to_load()
self.UTILS.test.test(self.url1 in self.browser.loaded_url(), "Web page loaded correctly.")
# Open the SMS app, send a message then jump back to the browser.
self.messages.launch()
self.messages.create_and_send_sms([self.num], self.test_msg)
send_time = self.messages.last_sent_message_timestamp()
self.messages.wait_for_message(send_time)
self.apps.kill_all()
time.sleep(2)
self.browser.launch()
self.browser.open_url(self.url2)
self.marionette.switch_to_frame()
self.browser.wait_for_page_to_load()
self.UTILS.test.test(self.url2 in self.browser.loaded_url(), "Web page loaded correctly.")
class test_main(GaiaTestCase):
def setUp(self):
GaiaTestCase.setUp(self)
self.UTILS = UTILS(self)
# Specific for this test.
self.browser = Browser(self)
self.settings = Settings(self)
self.download_manager = DownloadManager(self)
self.test_url = self.UTILS.general.get_config_variable("download_url", "common")
self.file_name = "Crazy_Horse.jpg"
self.data_url = "{}/{}".format(self.test_url, self.file_name)
self.connect_to_network()
self.settings.launch()
self.settings.downloads()
self.download_manager.clean_downloads_list()
self.apps.kill_all()
time.sleep(2)
def tearDown(self):
self.UTILS.reporting.reportResults()
GaiaTestCase.tearDown(self)
def test_run(self):
self.UTILS.statusbar.clearAllStatusBarNotifs()
self.browser.launch()
self.browser.open_url(self.test_url)
self.download_manager.download_file(self.file_name)
self.UTILS.statusbar.wait_for_notification_toaster_title("Download complete", timeout=60)
time.sleep(5)
self.settings.launch()
self.settings.downloads()
self.download_manager.verify_download_status(self.data_url, "succeeded")
self.download_manager.delete_download(self.data_url)
class test_main(GaiaTestCase):
def setUp(self):
GaiaTestCase.setUp(self)
self.UTILS = UTILS(self)
self.browser = Browser(self)
self.settings = Settings(self)
self.download_manager = DownloadManager(self)
self.test_url = self.UTILS.general.get_config_variable(
"download_url", "common")
self.file_name = "Crazy_Horse.jpg"
self.data_url = "{}/{}".format(self.test_url, self.file_name)
self.connect_to_network()
self.settings.launch()
self.settings.downloads()
self.download_manager.clean_downloads_list()
def tearDown(self):
self.UTILS.reporting.reportResults()
GaiaTestCase.tearDown(self)
def test_run(self):
self.browser.launch()
self.browser.open_url(self.test_url)
self.download_manager.download_file(self.file_name)
self.UTILS.statusbar.click_on_notification_title(
"Download complete",
frame_to_change=DOM.Gallery.frame_locator,
timeout=60)
# Verify that the image is opened.
time.sleep(2)
title = self.UTILS.element.getElement(DOM.Gallery.file_name_header,
"File name header")
self.UTILS.test.test(title.text == self.file_name,
"File name matches in Gallery")
self.UTILS.element.waitForElements(
DOM.Gallery.download_manager_preview,
"Waiting for image to be loaded")
class test_main(GaiaTestCase):
def setUp(self):
# Set up child objects...
GaiaTestCase.setUp(self)
self.UTILS = UTILS(self)
self.browser = Browser(self)
def tearDown(self):
self.UTILS.reporting.reportResults()
GaiaTestCase.tearDown(self)
def test_run(self):
test_url = "http://qatecnico.blogspot.com.es/search/label/Automatizaci%C3%B3n%20de%20Pruebas"
# Wifi needs to be off for this test to work.
self.data_layer.connect_to_cell_data()
# Open the browser app.
self.browser.launch()
self.browser.open_url(test_url)
class test_main(GaiaTestCase):
def setUp(self):
# Set up child objects...
GaiaTestCase.setUp(self)
self.UTILS = UTILS(self)
self.settings = Settings(self)
self.browser = Browser(self)
self.url1 = "www.google.com"
self.url2 = "www.wikipedia.org"
def tearDown(self):
self.UTILS.reporting.reportResults()
GaiaTestCase.tearDown(self)
def test_run(self):
self.data_layer.connect_to_wifi()
# Open the browser app.
self.browser.launch()
self.browser.open_url(self.url1)
self.marionette.switch_to_frame()
self.browser.wait_for_page_to_load()
self.UTILS.test.test(self.url1 in self.browser.loaded_url(),
"{} successfully loaded".format(self.url1))
self.device.turn_screen_off()
screenshot = self.UTILS.debug.screenShotOnErr()
self.UTILS.reporting.logResult("info", "Srceenshot of locked screen:",
screenshot)
time.sleep(3)
self.device.unlock()
self.browser.open_url(self.url2)
self.marionette.switch_to_frame()
self.browser.wait_for_page_to_load()
self.UTILS.test.test(self.url2 in self.browser.loaded_url(),
"{} successfully loaded".format(self.url2))
class test_main(GaiaTestCase):
def setUp(self):
# Set up child objects...
GaiaTestCase.setUp(self)
self.UTILS = UTILS(self)
self.browser = Browser(self)
def tearDown(self):
self.UTILS.reporting.reportResults()
GaiaTestCase.tearDown(self)
def test_run(self):
test_url = "http://qatecnico.blogspot.com.es/search/label/Automatizaci%C3%B3n%20de%20Pruebas"
# Wifi needs to be off for this test to work.
self.data_layer.connect_to_cell_data()
# Open the browser app.
self.browser.launch()
self.browser.open_url(test_url)
class test_main(GaiaTestCase):
def setUp(self):
# Set up child objects...
GaiaTestCase.setUp(self)
self.UTILS = UTILS(self)
self.settings = Settings(self)
self.browser = Browser(self)
self.url1 = "www.google.com"
self.url2 = "www.wikipedia.org"
def tearDown(self):
self.UTILS.reporting.reportResults()
GaiaTestCase.tearDown(self)
def test_run(self):
self.data_layer.connect_to_wifi()
# Open the browser app.
self.browser.launch()
self.browser.open_url(self.url1)
self.marionette.switch_to_frame()
self.browser.wait_for_page_to_load()
self.UTILS.test.test(self.url1 in self.browser.loaded_url(), "{} successfully loaded".format(self.url1))
self.device.turn_screen_off()
screenshot = self.UTILS.debug.screenShotOnErr()
self.UTILS.reporting.logResult("info", "Srceenshot of locked screen:", screenshot)
time.sleep(3)
self.device.unlock()
self.browser.open_url(self.url2)
self.marionette.switch_to_frame()
self.browser.wait_for_page_to_load()
self.UTILS.test.test(self.url2 in self.browser.loaded_url(), "{} successfully loaded".format(self.url2))
class test_main(GaiaTestCase):
def setUp(self):
# Set up child objects...
GaiaTestCase.setUp(self)
self.UTILS = UTILS(self)
self.settings = Settings(self)
self.browser = Browser(self)
self.wifi_name = self.UTILS.general.get_config_variable("ssid", "wifi")
self.wifi_pass = self.UTILS.general.get_config_variable(
"password", "wifi")
self.testURL = self.UTILS.general.get_config_variable(
"test_url", "common")
self.apps.set_permission_by_url(Browser.search_manifest_url,
'geolocation', 'deny')
# switch off keyboard FTU screen
self.data_layer.set_setting("keyboard.ftu.enabled", False)
def tearDown(self):
self.UTILS.reporting.reportResults()
GaiaTestCase.tearDown(self)
def test_run(self):
# Open the settings application.
self.settings.launch()
# Connect to the wifi.
self.settings.wifi()
self.settings.connect_to_wifi(self.wifi_name, self.wifi_pass)
# Open the browser app.
self.browser.launch()
# Open our URL.
self.browser.open_url(self.testURL)
class test_main(GaiaTestCase):
def setUp(self):
GaiaTestCase.setUp(self)
self.UTILS = UTILS(self)
self.browser = Browser(self)
self.settings = Settings(self)
self.download_manager = DownloadManager(self)
self.test_url = self.UTILS.general.get_config_variable("download_url", "common")
self.file_name = "Crazy_Horse.jpg"
self.data_url = "{}/{}".format(self.test_url, self.file_name)
self.connect_to_network()
self.settings.launch()
self.settings.downloads()
self.download_manager.clean_downloads_list()
def tearDown(self):
self.UTILS.reporting.reportResults()
GaiaTestCase.tearDown(self)
def test_run(self):
self.browser.launch()
self.browser.open_url(self.test_url)
self.download_manager.download_file(self.file_name)
self.UTILS.statusbar.click_on_notification_title(
"Download complete", frame_to_change=DOM.Gallery.frame_locator, timeout=60)
# Verify that the image is opened.
time.sleep(2)
title = self.UTILS.element.getElement(DOM.Gallery.file_name_header, "File name header")
self.UTILS.test.test(title.text == self.file_name, "File name matches in Gallery")
self.UTILS.element.waitForElements(DOM.Gallery.download_manager_preview, "Waiting for image to be loaded")
class test_main(GaiaTestCase):
def setUp(self):
GaiaTestCase.setUp(self)
self.UTILS = UTILS(self)
self.browser = Browser(self)
self.settings = Settings(self)
self.download_manager = DownloadManager(self)
self.test_url = self.UTILS.general.get_config_variable("download_url", "common")
self.file_names = [
"105MB.rar",
"41MB.rar",
"30MB.rar"
]
self.data_urls = ["{}/{}".format(self.test_url, file_name) for file_name in self.file_names]
# Progress trackers
self.pre_progresses = []
self.post_progresses = []
self.data_layer.connect_to_cell_data()
self.settings.launch()
self.settings.downloads()
self.download_manager.clean_downloads_list()
def tearDown(self):
self.UTILS.reporting.reportResults()
GaiaTestCase.tearDown(self)
def _download_multiple_files(self, file):
self.download_manager.download_file(file)
self.marionette.switch_to_frame()
self.UTILS.statusbar.wait_for_notification_toaster_title(
text="Download started", frame_to_change=DOM.Browser.frame_locator, timeout=15, notif_text="Downloading")
self.UTILS.reporting.logResult('info', 'Looking for next link!!!!')
self.browser.switch_to_content()
time.sleep(5)
def test_run(self):
self.UTILS.statusbar.clearAllStatusBarNotifs()
self.browser.launch()
self.browser.open_url(self.test_url)
map(self._download_multiple_files, self.file_names)
self.apps.kill_all()
time.sleep(2)
self.settings.launch()
self.settings.downloads()
for data_url in self.data_urls:
# Check the download is there
self.download_manager.get_download_entry(data_url)
# Check it is downloading
self.download_manager.verify_download_status(data_url, "downloading")
self.download_manager.verify_download_graphical_status(data_url, "downloading")
# Append the progress
self.pre_progresses.append(self.download_manager.get_download_progress(data_url))
time.sleep(10)
for data_url in self.data_urls:
self.post_progresses.append(self.download_manager.get_download_progress(data_url))
self.UTILS.reporting.logResult('info', "Initial progress array: {}".format(self.pre_progresses))
self.UTILS.reporting.logResult('info', "Final progress array: {}".format(self.post_progresses))
result = all([self.pre_progresses[i] < self.post_progresses[i]
for i in range(len(self.file_names))])
self.UTILS.test.test(result, "The progress bar grows during the download.")
class Loop(object):
"""Object representing the Loop application.
"""
def __init__(self, parent):
self.apps = parent.apps
self.data_layer = parent.data_layer
self.parent = parent
self.marionette = parent.marionette
self.UTILS = parent.UTILS
self.actions = Actions(self.marionette)
self.browser = Browser(self.parent)
self.app_name = "Firefox Hello"
self.market_url = "https://owd.tid.es/B3lg1r89n/market/appList.html"
self.persistent_directory = "/data/local/storage/persistent"
self.loop_dir = self.UTILS.general.get_config_variable(
"install_dir", "loop")
def launch(self):
"""
Launch the app.
"""
self.app = self.apps.launch(self.app_name)
self.UTILS.element.waitForNotElements(
DOM.GLOBAL.loading_overlay,
self.__class__.__name__ + " app - loading overlay")
return self.app
def is_installed(self):
return self.apps.is_app_installed(self.app_name)
def install(self):
via = self.UTILS.general.get_config_variable("install_via", "loop")
if via == "Grunt":
self.install_via_grunt()
elif via == "Market":
self.install_via_marketplace()
else:
self.UTILS.test.test(False, "Not valid way to install Loop")
def install_via_grunt(self, version="1.1"):
self.UTILS.reporting.logResult('info', 'Installing via grunt....')
c1 = 'cd {}'.format(self.loop_dir)
c2 = 'git checkout {}'.format(version)
c3 = 'git fetch && git merge origin/{}'.format(version)
c4 = 'grunt build'
with open(os.devnull, 'w') as DEVNULL:
result = subprocess32.check_output("; ".join([c1, c2, c3, c4]),
shell=True,
stderr=DEVNULL)
self.marionette.switch_to_frame()
msg = "{} installed".format(self.app_name)
installed_app_msg = (DOM.GLOBAL.system_banner_msg[0],
DOM.GLOBAL.system_banner_msg[1].format(msg))
self.UTILS.element.waitForElements(installed_app_msg,
"App installed",
timeout=30)
install_ok_msg = "Done, without errors."
self.UTILS.reporting.logResult(
'info', "Result of this test script: {}".format(result))
self.UTILS.test.test(install_ok_msg in result,
"Install via grunt is OK")
def install_via_marketplace(self):
self.UTILS.reporting.logResult('info',
'Installing via marketplace....')
# Make sure we install the latest version
self.update_and_publish()
self.browser.launch()
time.sleep(1)
self.browser.open_url(self.market_url)
loop_link = self.UTILS.element.getElement(
('xpath', '//p[contains(text(), "{}")]'.format(self.app_name)),
"App link")
loop_link.tap()
self.marionette.switch_to_frame()
install_ok = self.UTILS.element.getElement(DOM.GLOBAL.app_install_ok,
"Install button")
install_ok.tap()
msg = "{} installed".format(self.app_name)
installed_app_msg = (DOM.GLOBAL.system_banner_msg[0],
DOM.GLOBAL.system_banner_msg[1].format(msg))
self.UTILS.element.waitForElements(installed_app_msg,
"App installed",
timeout=30)
def reinstall(self):
self.uninstall()
time.sleep(2)
self.install()
def uninstall(self):
self.UTILS.reporting.logResult('info', "uninstalling.........")
self.apps.uninstall(self.app_name)
self.parent.wait_for_condition(
lambda m: not self.apps.is_app_installed(self.app_name),
timeout=20,
message="{} is not installed".format(self.app_name))
def update_and_publish(self):
self.publish_loop_dir = self.UTILS.general.get_config_variable(
"aux_files", "loop")
c1 = 'cd {}'.fomrat(self.publish_loop_dir)
c2 = './publish_app.sh {}'.format(self.loop_dir)
with open(os.devnull, 'w') as DEVNULL:
result = subprocess32.check_output("; ".join([c1, c2]),
shell=True,
stderr=DEVNULL)
chops = result.split("\n")
self.UTILS.reporting.logResult('info', "result: {}".format(chops))
self.UTILS.test.test("And all done, hopefully." in chops,
"The script to publish an app is OK", True)
def _fill_fxa_field(self, field_locator, text):
""" Auxiliary method to fill "Firefox account login" fields
"""
self.UTILS.reporting.logResult(
'info',
'[firefox_login] Filling fxa field with text: {}'.format(text))
self.parent.wait_for_element_displayed(*field_locator)
fxa_input = self.marionette.find_element(*field_locator)
fxa_input.send_keys(text)
time.sleep(2)
self.parent.wait_for_condition(
lambda m: m.find_element(*DOM.Loop.ffox_account_login_next
).get_attribute("disabled") != "disabled")
next_btn = self.marionette.find_element(
*DOM.Loop.ffox_account_login_next)
next_btn.tap()
self.parent.wait_for_element_not_displayed(
*DOM.Loop.ffox_account_login_overlay)
def tap_on_firefox_login_button(self):
ffox_btn = self.marionette.find_element(
*DOM.Loop.wizard_login_ffox_account)
self.UTILS.element.simulateClick(ffox_btn)
def _tap_on_phone_login_button(self):
phone_btn = self.marionette.find_element(
*DOM.Loop.wizard_login_phone_number)
self.UTILS.element.simulateClick(phone_btn)
def _get_mobile_id_options(self):
return self.marionette.find_elements(*DOM.Loop.mobile_id_sim_list_item)
def wizard_or_login(self):
""" Checks if we have to skip the Wizard, log in, or if we're already at the main screen of Loop
For the first two scenarios, it returns True.
If we are already inside Loop, it returns False.
"""
# TODO: switch try-except code -> first check login instead of wizard
# see if it works, when the wizard is first
try:
self.parent.wait_for_element_displayed(*DOM.Loop.wizard_header)
self.UTILS.reporting.logResult('info', '[wizard_or_login] Wizard')
self.skip_wizard()
return True
except:
self.UTILS.reporting.logResult('info', '[wizard_or_login] Login')
try:
self.parent.wait_for_element_displayed(*DOM.Loop.wizard_login)
return True
except:
self.UTILS.reporting.logResult('info',
'[wizard_or_login] Loop')
try:
self.parent.wait_for_element_displayed(
*DOM.Loop.app_header)
return False
except:
self.UTILS.test.test(False, "Ooops. Something went wrong",
True)
def get_wizard_steps(self):
""" Returns the number of steps of the wizard
"""
return len(
self.marionette.find_elements(*DOM.Loop.wizard_slideshow_step))
def skip_wizard(self):
""" Skips first time use wizard by flicking the screen
"""
time.sleep(1)
wizard_steps = self.get_wizard_steps()
current_frame = self.apps.displayed_app.frame
x_start = current_frame.size['width'] // 2
x_end = x_start // 4
y_start = current_frame.size['height'] // 2
for i in range(wizard_steps):
self.actions.flick(current_frame,
x_start,
y_start,
x_end,
y_start,
duration=600).perform()
time.sleep(1)
self.marionette.switch_to_frame(self.apps.displayed_app.frame_id)
self.parent.wait_for_element_displayed(DOM.Loop.wizard_login[0],
DOM.Loop.wizard_login[1],
timeout=10)
def firefox_login(self, email, password, is_wrong=False):
""" Logs in using Firefox account
"""
self.tap_on_firefox_login_button()
self.UTILS.iframe.switchToFrame(*DOM.Loop.ffox_account_frame_locator)
self.parent.wait_for_element_displayed(
DOM.Loop.ffox_account_login_title[0],
DOM.Loop.ffox_account_login_title[1],
timeout=20)
self._fill_fxa_field(DOM.Loop.ffox_account_login_mail, email)
self._fill_fxa_field(DOM.Loop.ffox_account_login_pass, password)
if not is_wrong:
done_btn = self.marionette.find_element(
*DOM.Loop.ffox_account_login_done)
done_btn.tap()
def phone_login_auto(self, phone_number, option_number=1):
"""Wrapper to log in using phone number, either the already selected or entering it manually"""
try:
self.UTILS.reporting.info("Trying phone login using Mobile ID")
self.phone_login()
except:
self.UTILS.reporting.info(
"Mobile ID login failed, falling back to manual")
self.UTILS.iframe.switchToFrame(*DOM.Loop.mobile_id_frame_locator)
self.marionette.find_element('id', 'header').tap(25, 25)
self.UTILS.iframe.switchToFrame(*DOM.Loop.frame_locator)
self.phone_login_manually(phone_number)
@retry(3,
context=("OWDTestToolkit.apps.loop", "Loop"),
aux_func_name="retry_phone_login")
def phone_login(self, option_number=1):
""" Logs in using mobile id
"""
self._tap_on_phone_login_button()
self.UTILS.iframe.switchToFrame(*DOM.Loop.mobile_id_frame_locator)
self.parent.wait_for_element_not_displayed(
*DOM.Loop.ffox_account_login_overlay)
mobile_id_header = ("xpath",
DOM.GLOBAL.app_head_specific.format(
_("Mobile ID")))
self.parent.wait_for_element_displayed(*mobile_id_header)
options = self._get_mobile_id_options()
if len(options) > 1:
# Option number refers to the SIM number (1 or 2), not to the position in the array
options[option_number - 1].tap()
allow_button = self.marionette.find_element(
*DOM.Loop.mobile_id_allow_button)
allow_button.tap()
try:
self.parent.wait_for_element_displayed(
DOM.Loop.mobile_id_verified_button[0],
DOM.Loop.mobile_id_verified_button[1],
timeout=30)
verified_button = self.marionette.find_element(
*DOM.Loop.mobile_id_verified_button)
self.UTILS.element.simulateClick(verified_button)
except:
self.parent.wait_for_condition(
lambda m: "state-sending" in m.find_element(
*DOM.Loop.mobile_id_allow_button).get_attribute("class"),
timeout=5,
message="Button is still sending")
# Make @retry do its work
raise
self.apps.switch_to_displayed_app()
@retry(3,
context=("OWDTestToolkit.apps.loop", "Loop"),
aux_func_name="retry_phone_login")
def phone_login_manually(self, phone_number_without_prefix):
"""
Logs in using mobile id, but instead of using the automatically provided by the app
selecting the manual option
@phone_number_without_prefix str Phone number to register into Loop
NOTE: for the shake of simplicity, we assume the prefix is the spanish one (+34) by default
"""
self._tap_on_phone_login_button()
self.UTILS.iframe.switchToFrame(*DOM.Loop.mobile_id_frame_locator)
self.parent.wait_for_element_not_displayed(
*DOM.Loop.ffox_account_login_overlay)
mobile_id_header = ("xpath",
DOM.GLOBAL.app_head_specific.format(
_("Mobile ID")))
self.parent.wait_for_element_displayed(*mobile_id_header)
# Manually!
manually_link = self.marionette.find_element(
*DOM.Loop.mobile_id_add_phone_number)
manually_link.tap()
self.parent.wait_for_element_displayed(
*DOM.Loop.mobile_id_add_phone_number_number)
phone_input = self.marionette.find_element(
*DOM.Loop.mobile_id_add_phone_number_number)
phone_input.send_keys(phone_number_without_prefix)
# NOTE: before you virtually kill me, I cannot take this duplicated code into another
# separated method due to the @reply decorator. Just letting you know :).
allow_button = self.marionette.find_element(
*DOM.Loop.mobile_id_allow_button)
allow_button.tap()
try:
self.parent.wait_for_element_displayed(
DOM.Loop.mobile_id_verified_button[0],
DOM.Loop.mobile_id_verified_button[1],
timeout=30)
verified_button = self.marionette.find_element(
*DOM.Loop.mobile_id_verified_button)
self.UTILS.element.simulateClick(verified_button)
except:
self.parent.wait_for_condition(
lambda m: "state-sending" in m.find_element(
*DOM.Loop.mobile_id_allow_button).get_attribute("class"),
timeout=5,
message="Button is still sending")
# Make @retry do its work
raise
self.apps.switch_to_displayed_app()
@retry(5,
context=("OWDTestToolkit.apps.loop", "Loop"),
aux_func_name="retry_ffox_login")
def allow_permission_ffox_login(self):
""" Allows Loop to read our contacts
This method checks whether is necessary to allow extra permissions for loop or not ater
loggin in with Firefox accounts
Also, since this is is the last step before connecting to the Loop server, it checks
that no error has been raised. If that happens, it retries the connection up to 5 times.
"""
self.marionette.switch_to_frame()
try:
self.UTILS.reporting.debug("Looking for permission panel....")
self.parent.wait_for_element_displayed(
DOM.GLOBAL.app_permission_dialog[0],
DOM.GLOBAL.app_permission_dialog[1],
timeout=10)
except:
try:
self.UTILS.reporting.debug(
"Now looking for permission Loop main view....")
self.apps.switch_to_displayed_app()
self.parent.wait_for_element_displayed(*DOM.Loop.app_header)
return
except:
self.UTILS.reporting.debug("And Now looking for error....")
self.marionette.switch_to_frame()
self.parent.wait_for_element_displayed(
*DOM.GLOBAL.modal_dialog_alert_title)
self.UTILS.reporting.logResult('info', "Error connecting...")
# Make @retry do its work
raise
msg_text = self.marionette.find_element(
*DOM.GLOBAL.app_permission_msg).text
self.UTILS.test.test(self.app_name in msg_text, "Permissions for loop")
allow_btn = self.marionette.find_element(
*DOM.GLOBAL.app_permission_btn_yes)
self.UTILS.element.simulateClick(allow_btn)
self.apps.switch_to_displayed_app()
def allow_permission_phone_login(self):
""" Allows Loop to read our contacts
This method checks whether is necessary to allow extra permissions for loop or not ater
loggin in with Mobile ID
Also, since this is is the last step before connecting to the Loop server, it checks
that no error has been raised. If that happens, it retries the connection up to 5 times.
"""
self.marionette.switch_to_frame()
try:
self.UTILS.reporting.debug("Looking for permission panel....")
self.parent.wait_for_element_displayed(
DOM.GLOBAL.app_permission_dialog[0],
DOM.GLOBAL.app_permission_dialog[1],
timeout=10)
except:
self.UTILS.reporting.debug(
"Now looking for permission Loop main view....")
self.apps.switch_to_displayed_app()
self.parent.wait_for_element_displayed(*DOM.Loop.app_header)
return
msg_text = self.marionette.find_element(
*DOM.GLOBAL.app_permission_msg).text
self.UTILS.test.test(self.app_name in msg_text, "Permissions for loop")
allow_btn = self.marionette.find_element(
*DOM.GLOBAL.app_permission_btn_yes)
self.UTILS.element.simulateClick(allow_btn)
self.apps.switch_to_displayed_app()
def retry_ffox_login(self):
""" Retry Ffox account login if it has failed.
This method is called as the aux_func for our brand new retry decorator
"""
self.UTILS.reporting.logResult('info', "Retrying FxA login...")
self.apps.switch_to_displayed_app()
time.sleep(2)
self.parent.wait_for_element_displayed(*DOM.Loop.error_screen_ok)
ok_btn = self.marionette.find_element(*DOM.Loop.error_screen_ok)
self.UTILS.element.simulateClick(ok_btn)
self.parent.wait_for_element_displayed(*DOM.Loop.wizard_login)
self.tap_on_firefox_login_button()
def retry_phone_login(self):
""" Retry phone login if it has failed
"""
self.UTILS.reporting.logResult('info', "Retrying phone login...")
self.parent.wait_for_element_displayed(*DOM.Loop.mobile_id_back)
back_btn = self.marionette.find_element(*DOM.Loop.mobile_id_back)
self.UTILS.element.simulateClick(back_btn)
self.apps.switch_to_displayed_app()
time.sleep(2)
self._tap_on_phone_login_button()
def open_settings(self):
""" Open settings panel from call log
"""
self.parent.wait_for_element_displayed(*DOM.Loop.open_settings_btn)
settings_btn = self.marionette.find_element(
*DOM.Loop.open_settings_btn)
self.UTILS.element.simulateClick(settings_btn)
self.parent.wait_for_element_displayed(*DOM.Loop.settings_panel_header)
def logout(self, confirm=True):
""" This methods logs us out from Loop.
It assumes we already are in the Loop Settings panel
"""
try:
self.parent.wait_for_element_displayed(*DOM.Loop.settings_logout)
except:
self.UTILS.reporting.logResult('info', "Already logged out")
return
logout_btn = self.marionette.find_element(*DOM.Loop.settings_logout)
self.UTILS.element.simulateClick(logout_btn)
self.parent.wait_for_element_displayed(*DOM.Loop.form_confirm_logout)
if confirm:
confirm_btn = self.marionette.find_element(
*DOM.Loop.form_confirm_logout)
self.UTILS.element.simulateClick(confirm_btn)
self.parent.wait_for_element_not_displayed(
*DOM.Loop.loading_overlay)
self.parent.wait_for_element_displayed(*DOM.Loop.wizard_login)
else:
cancel_btn = self.marionette.find_element(
*DOM.Loop.form_confirm_cancel)
self.parent.wait_for_element_displayed(
*DOM.Loop.settings_panel_header)
def switch_to_urls(self):
self.parent.wait_for_element_displayed(
*DOM.Loop.call_log_shared_links_tab)
tab = self.marionette.find_element(*DOM.Loop.call_log_shared_links_tab)
tab.tap()
self.parent.wait_for_condition(
lambda m: tab.get_attribute("aria-selected") == "true",
timeout=10,
message="Checking that 'Shared links' is selected")
def _get_number_of_urls(self, locator):
try:
entries = self.marionette.find_elements(*locator)
return len(entries)
except:
return 0
def get_number_of_all_urls(self):
return self._get_number_of_urls(DOM.Loop.shared_links_entry)
def get_number_of_available_urls(self):
return self._get_number_of_urls(DOM.Loop.shared_links_entry_available)
def get_number_of_revoked_urls(self):
return self._get_number_of_urls(DOM.Loop.shared_links_entry_revoked)
def _select_action(self, action):
elem = (DOM.Loop.form_action_action[0],
DOM.Loop.form_action_action[1].format(action))
self.parent.wait_for_element_displayed(*elem)
self.marionette.find_element(*elem).tap()
def _confirm(self, decission):
elem = DOM.Loop.form_confirm_delete if decission else DOM.Loop.form_confirm_cancel
self.parent.wait_for_element_displayed(*elem)
self.marionette.find_element(*elem).tap()
def _is_entry_revoked(self, entry):
try:
entry.find_element(*DOM.Loop.shared_links_entry_revoked_nested)
return True
except Exception, e:
self.UTILS.reporting.logResult('info',
"What happened here? {}".format(e))
return False
class test_main(GaiaTestCase):
button_locator = ('css selector', "button.icon")
def setUp(self):
GaiaTestCase.setUp(self)
self.UTILS = UTILS(self)
self.browser = Browser(self)
self.settings = Settings(self)
self.download_manager = DownloadManager(self)
self.test_url = self.UTILS.general.get_config_variable(
"download_url", "common")
self.file_name = "clipcanvas_14348_H264_320x180.mp4"
self.data_url = "{}/{}".format(self.test_url, self.file_name)
self.connect_to_network()
self.settings.launch()
self.settings.downloads()
self.download_manager.clean_downloads_list()
self.apps.kill_all()
time.sleep(2)
def tearDown(self):
self.UTILS.reporting.reportResults()
GaiaTestCase.tearDown(self)
def test_run(self):
self.UTILS.statusbar.clearAllStatusBarNotifs()
self.browser.launch()
self.browser.open_url(self.test_url)
self.download_manager.download_file(self.file_name)
self.UTILS.statusbar.wait_for_notification_toaster_title(
"Download complete", timeout=60)
time.sleep(3)
self.settings.launch()
self.settings.downloads()
self.download_manager.open_download(self.data_url)
share_option = self.UTILS.element.getElement(
DOM.DownloadManager.download_file_option_share,
"Getting Share option button")
share_option.tap()
self.marionette.switch_to_frame()
share_menu = self.UTILS.element.getElement(DOM.GLOBAL.action_menu,
"Share menu")
options = share_menu.find_elements(*self.button_locator)
self.UTILS.test.test(
len(options) > 0, "A list with several options to share is shown")
self._show_option(options)
def _show_option(self, options):
for option in options:
self.UTILS.reporting.logResult(
'info', "Share option: {}".format(option.text))
class Loop(object):
"""Object representing the Loop application.
"""
def __init__(self, parent):
self.apps = parent.apps
self.data_layer = parent.data_layer
self.parent = parent
self.marionette = parent.marionette
self.UTILS = parent.UTILS
self.actions = Actions(self.marionette)
self.browser = Browser(self.parent)
self.app_name = "Firefox Hello"
self.market_url = "https://owd.tid.es/B3lg1r89n/market/appList.html"
self.persistent_directory = "/data/local/storage/persistent"
self.loop_dir = self.UTILS.general.get_config_variable("install_dir", "loop")
def launch(self):
"""
Launch the app.
"""
self.app = self.apps.launch(self.app_name)
self.UTILS.element.waitForNotElements(DOM.GLOBAL.loading_overlay,
self.__class__.__name__ + " app - loading overlay")
return self.app
def is_installed(self):
return self.apps.is_app_installed(self.app_name)
def install(self):
via = self.UTILS.general.get_config_variable("install_via", "loop")
if via == "Grunt":
self.install_via_grunt()
elif via == "Market":
self.install_via_marketplace()
else:
self.UTILS.test.test(False, "Not valid way to install Loop")
def install_via_grunt(self, version="1.1"):
self.UTILS.reporting.logResult('info', 'Installing via grunt....')
c1 = 'cd {}'.format(self.loop_dir)
c2 = 'git checkout {}'.format(version)
c3 = 'git fetch && git merge origin/{}'.format(version)
c4 = 'grunt build'
with open(os.devnull, 'w') as DEVNULL:
result = subprocess32.check_output("; ".join([c1, c2, c3, c4]), shell=True, stderr=DEVNULL)
self.marionette.switch_to_frame()
msg = "{} installed".format(self.app_name)
installed_app_msg = (DOM.GLOBAL.system_banner_msg[0], DOM.GLOBAL.system_banner_msg[1].format(msg))
self.UTILS.element.waitForElements(installed_app_msg, "App installed", timeout=30)
install_ok_msg = "Done, without errors."
self.UTILS.reporting.logResult('info', "Result of this test script: {}".format(result))
self.UTILS.test.test(install_ok_msg in result, "Install via grunt is OK")
def install_via_marketplace(self):
self.UTILS.reporting.logResult('info', 'Installing via marketplace....')
# Make sure we install the latest version
self.update_and_publish()
self.browser.launch()
time.sleep(1)
self.browser.open_url(self.market_url)
loop_link = self.UTILS.element.getElement(
('xpath', '//p[contains(text(), "{}")]'.format(self.app_name)), "App link")
loop_link.tap()
self.marionette.switch_to_frame()
install_ok = self.UTILS.element.getElement(DOM.GLOBAL.app_install_ok, "Install button")
install_ok.tap()
msg = "{} installed".format(self.app_name)
installed_app_msg = (DOM.GLOBAL.system_banner_msg[0], DOM.GLOBAL.system_banner_msg[1].format(msg))
self.UTILS.element.waitForElements(installed_app_msg, "App installed", timeout=30)
def reinstall(self):
self.uninstall()
time.sleep(2)
self.install()
def uninstall(self):
self.UTILS.reporting.logResult('info', "uninstalling.........")
self.apps.uninstall(self.app_name)
self.parent.wait_for_condition(lambda m: not self.apps.is_app_installed(
self.app_name), timeout=20, message="{} is not installed".format(self.app_name))
def update_and_publish(self):
self.publish_loop_dir = self.UTILS.general.get_config_variable("aux_files", "loop")
c1 = 'cd {}'.fomrat(self.publish_loop_dir)
c2 = './publish_app.sh {}'.format(self.loop_dir)
with open(os.devnull, 'w') as DEVNULL:
result = subprocess32.check_output("; ".join([c1, c2]), shell=True, stderr=DEVNULL)
chops = result.split("\n")
self.UTILS.reporting.logResult('info', "result: {}".format(chops))
self.UTILS.test.test("And all done, hopefully." in chops, "The script to publish an app is OK", True)
def _fill_fxa_field(self, field_locator, text):
""" Auxiliary method to fill "Firefox account login" fields
"""
self.UTILS.reporting.logResult('info', '[firefox_login] Filling fxa field with text: {}'.format(text))
self.parent.wait_for_element_displayed(*field_locator)
fxa_input = self.marionette.find_element(*field_locator)
fxa_input.send_keys(text)
time.sleep(2)
self.parent.wait_for_condition(
lambda m: m.find_element(*DOM.Loop.ffox_account_login_next).get_attribute("disabled") != "disabled")
next_btn = self.marionette.find_element(*DOM.Loop.ffox_account_login_next)
next_btn.tap()
self.parent.wait_for_element_not_displayed(*DOM.Loop.ffox_account_login_overlay)
def tap_on_firefox_login_button(self):
ffox_btn = self.marionette.find_element(*DOM.Loop.wizard_login_ffox_account)
self.UTILS.element.simulateClick(ffox_btn)
def _tap_on_phone_login_button(self):
phone_btn = self.marionette.find_element(*DOM.Loop.wizard_login_phone_number)
self.UTILS.element.simulateClick(phone_btn)
def _get_mobile_id_options(self):
return self.marionette.find_elements(*DOM.Loop.mobile_id_sim_list_item)
def wizard_or_login(self):
""" Checks if we have to skip the Wizard, log in, or if we're already at the main screen of Loop
For the first two scenarios, it returns True.
If we are already inside Loop, it returns False.
"""
# TODO: switch try-except code -> first check login instead of wizard
# see if it works, when the wizard is first
try:
self.parent.wait_for_element_displayed(*DOM.Loop.wizard_header)
self.UTILS.reporting.logResult('info', '[wizard_or_login] Wizard')
self.skip_wizard()
return True
except:
self.UTILS.reporting.logResult('info', '[wizard_or_login] Login')
try:
self.parent.wait_for_element_displayed(*DOM.Loop.wizard_login)
return True
except:
self.UTILS.reporting.logResult('info', '[wizard_or_login] Loop')
try:
self.parent.wait_for_element_displayed(*DOM.Loop.app_header)
return False
except:
self.UTILS.test.test(False, "Ooops. Something went wrong", True)
def get_wizard_steps(self):
""" Returns the number of steps of the wizard
"""
return len(self.marionette.find_elements(*DOM.Loop.wizard_slideshow_step))
def skip_wizard(self):
""" Skips first time use wizard by flicking the screen
"""
time.sleep(1)
wizard_steps = self.get_wizard_steps()
current_frame = self.apps.displayed_app.frame
x_start = current_frame.size['width'] // 2
x_end = x_start // 4
y_start = current_frame.size['height'] // 2
for i in range(wizard_steps):
self.actions.flick(current_frame, x_start, y_start, x_end, y_start, duration=600).perform()
time.sleep(1)
self.marionette.switch_to_frame(self.apps.displayed_app.frame_id)
self.parent.wait_for_element_displayed(DOM.Loop.wizard_login[0], DOM.Loop.wizard_login[1], timeout=10)
def firefox_login(self, email, password, is_wrong=False):
""" Logs in using Firefox account
"""
self.tap_on_firefox_login_button()
self.UTILS.iframe.switchToFrame(*DOM.Loop.ffox_account_frame_locator)
self.parent.wait_for_element_displayed(
DOM.Loop.ffox_account_login_title[0], DOM.Loop.ffox_account_login_title[1], timeout=20)
self._fill_fxa_field(DOM.Loop.ffox_account_login_mail, email)
self._fill_fxa_field(DOM.Loop.ffox_account_login_pass, password)
if not is_wrong:
done_btn = self.marionette.find_element(*DOM.Loop.ffox_account_login_done)
done_btn.tap()
def phone_login_auto(self, phone_number, option_number=1):
"""Wrapper to log in using phone number, either the already selected or entering it manually"""
try:
self.UTILS.reporting.info("Trying phone login using Mobile ID")
self.phone_login()
except:
self.UTILS.reporting.info("Mobile ID login failed, falling back to manual")
self.UTILS.iframe.switchToFrame(*DOM.Loop.mobile_id_frame_locator)
self.marionette.find_element('id', 'header').tap(25, 25)
self.UTILS.iframe.switchToFrame(*DOM.Loop.frame_locator)
self.phone_login_manually(phone_number)
@retry(3, context=("OWDTestToolkit.apps.loop", "Loop"), aux_func_name="retry_phone_login")
def phone_login(self, option_number=1):
""" Logs in using mobile id
"""
self._tap_on_phone_login_button()
self.UTILS.iframe.switchToFrame(*DOM.Loop.mobile_id_frame_locator)
self.parent.wait_for_element_not_displayed(*DOM.Loop.ffox_account_login_overlay)
mobile_id_header = ("xpath", DOM.GLOBAL.app_head_specific.format(_("Mobile ID")))
self.parent.wait_for_element_displayed(*mobile_id_header)
options = self._get_mobile_id_options()
if len(options) > 1:
# Option number refers to the SIM number (1 or 2), not to the position in the array
options[option_number - 1].tap()
allow_button = self.marionette.find_element(*DOM.Loop.mobile_id_allow_button)
allow_button.tap()
try:
self.parent.wait_for_element_displayed(
DOM.Loop.mobile_id_verified_button[0], DOM.Loop.mobile_id_verified_button[1], timeout=30)
verified_button = self.marionette.find_element(*DOM.Loop.mobile_id_verified_button)
self.UTILS.element.simulateClick(verified_button)
except:
self.parent.wait_for_condition(lambda m: "state-sending" in m.find_element(
*DOM.Loop.mobile_id_allow_button).get_attribute("class"), timeout=5, message="Button is still sending")
# Make @retry do its work
raise
self.apps.switch_to_displayed_app()
@retry(3, context=("OWDTestToolkit.apps.loop", "Loop"), aux_func_name="retry_phone_login")
def phone_login_manually(self, phone_number_without_prefix):
"""
Logs in using mobile id, but instead of using the automatically provided by the app
selecting the manual option
@phone_number_without_prefix str Phone number to register into Loop
NOTE: for the shake of simplicity, we assume the prefix is the spanish one (+34) by default
"""
self._tap_on_phone_login_button()
self.UTILS.iframe.switchToFrame(*DOM.Loop.mobile_id_frame_locator)
self.parent.wait_for_element_not_displayed(*DOM.Loop.ffox_account_login_overlay)
mobile_id_header = ("xpath", DOM.GLOBAL.app_head_specific.format(_("Mobile ID")))
self.parent.wait_for_element_displayed(*mobile_id_header)
# Manually!
manually_link = self.marionette.find_element(*DOM.Loop.mobile_id_add_phone_number)
manually_link.tap()
self.parent.wait_for_element_displayed(*DOM.Loop.mobile_id_add_phone_number_number)
phone_input = self.marionette.find_element(*DOM.Loop.mobile_id_add_phone_number_number)
phone_input.send_keys(phone_number_without_prefix)
# NOTE: before you virtually kill me, I cannot take this duplicated code into another
# separated method due to the @reply decorator. Just letting you know :).
allow_button = self.marionette.find_element(*DOM.Loop.mobile_id_allow_button)
allow_button.tap()
try:
self.parent.wait_for_element_displayed(
DOM.Loop.mobile_id_verified_button[0], DOM.Loop.mobile_id_verified_button[1], timeout=30)
verified_button = self.marionette.find_element(*DOM.Loop.mobile_id_verified_button)
self.UTILS.element.simulateClick(verified_button)
except:
self.parent.wait_for_condition(lambda m: "state-sending" in m.find_element(
*DOM.Loop.mobile_id_allow_button).get_attribute("class"), timeout=5, message="Button is still sending")
# Make @retry do its work
raise
self.apps.switch_to_displayed_app()
@retry(5, context=("OWDTestToolkit.apps.loop", "Loop"), aux_func_name="retry_ffox_login")
def allow_permission_ffox_login(self):
""" Allows Loop to read our contacts
This method checks whether is necessary to allow extra permissions for loop or not ater
loggin in with Firefox accounts
Also, since this is is the last step before connecting to the Loop server, it checks
that no error has been raised. If that happens, it retries the connection up to 5 times.
"""
self.marionette.switch_to_frame()
try:
self.UTILS.reporting.debug("Looking for permission panel....")
self.parent.wait_for_element_displayed(
DOM.GLOBAL.app_permission_dialog[0], DOM.GLOBAL.app_permission_dialog[1], timeout=10)
except:
try:
self.UTILS.reporting.debug("Now looking for permission Loop main view....")
self.apps.switch_to_displayed_app()
self.parent.wait_for_element_displayed(*DOM.Loop.app_header)
return
except:
self.UTILS.reporting.debug("And Now looking for error....")
self.marionette.switch_to_frame()
self.parent.wait_for_element_displayed(*DOM.GLOBAL.modal_dialog_alert_title)
self.UTILS.reporting.logResult('info', "Error connecting...")
# Make @retry do its work
raise
msg_text = self.marionette.find_element(*DOM.GLOBAL.app_permission_msg).text
self.UTILS.test.test(self.app_name in msg_text, "Permissions for loop")
allow_btn = self.marionette.find_element(*DOM.GLOBAL.app_permission_btn_yes)
self.UTILS.element.simulateClick(allow_btn)
self.apps.switch_to_displayed_app()
def allow_permission_phone_login(self):
""" Allows Loop to read our contacts
This method checks whether is necessary to allow extra permissions for loop or not ater
loggin in with Mobile ID
Also, since this is is the last step before connecting to the Loop server, it checks
that no error has been raised. If that happens, it retries the connection up to 5 times.
"""
self.marionette.switch_to_frame()
try:
self.UTILS.reporting.debug("Looking for permission panel....")
self.parent.wait_for_element_displayed(
DOM.GLOBAL.app_permission_dialog[0], DOM.GLOBAL.app_permission_dialog[1], timeout=10)
except:
self.UTILS.reporting.debug("Now looking for permission Loop main view....")
self.apps.switch_to_displayed_app()
self.parent.wait_for_element_displayed(*DOM.Loop.app_header)
return
msg_text = self.marionette.find_element(*DOM.GLOBAL.app_permission_msg).text
self.UTILS.test.test(self.app_name in msg_text, "Permissions for loop")
allow_btn = self.marionette.find_element(*DOM.GLOBAL.app_permission_btn_yes)
self.UTILS.element.simulateClick(allow_btn)
self.apps.switch_to_displayed_app()
def retry_ffox_login(self):
""" Retry Ffox account login if it has failed.
This method is called as the aux_func for our brand new retry decorator
"""
self.UTILS.reporting.logResult('info', "Retrying FxA login...")
self.apps.switch_to_displayed_app()
time.sleep(2)
self.parent.wait_for_element_displayed(*DOM.Loop.error_screen_ok)
ok_btn = self.marionette.find_element(*DOM.Loop.error_screen_ok)
self.UTILS.element.simulateClick(ok_btn)
self.parent.wait_for_element_displayed(*DOM.Loop.wizard_login)
self.tap_on_firefox_login_button()
def retry_phone_login(self):
""" Retry phone login if it has failed
"""
self.UTILS.reporting.logResult('info', "Retrying phone login...")
self.parent.wait_for_element_displayed(*DOM.Loop.mobile_id_back)
back_btn = self.marionette.find_element(*DOM.Loop.mobile_id_back)
self.UTILS.element.simulateClick(back_btn)
self.apps.switch_to_displayed_app()
time.sleep(2)
self._tap_on_phone_login_button()
def open_settings(self):
""" Open settings panel from call log
"""
self.parent.wait_for_element_displayed(*DOM.Loop.open_settings_btn)
settings_btn = self.marionette.find_element(*DOM.Loop.open_settings_btn)
self.UTILS.element.simulateClick(settings_btn)
self.parent.wait_for_element_displayed(*DOM.Loop.settings_panel_header)
def logout(self, confirm=True):
""" This methods logs us out from Loop.
It assumes we already are in the Loop Settings panel
"""
try:
self.parent.wait_for_element_displayed(*DOM.Loop.settings_logout)
except:
self.UTILS.reporting.logResult('info', "Already logged out")
return
logout_btn = self.marionette.find_element(*DOM.Loop.settings_logout)
self.UTILS.element.simulateClick(logout_btn)
self.parent.wait_for_element_displayed(*DOM.Loop.form_confirm_logout)
if confirm:
confirm_btn = self.marionette.find_element(*DOM.Loop.form_confirm_logout)
self.UTILS.element.simulateClick(confirm_btn)
self.parent.wait_for_element_not_displayed(*DOM.Loop.loading_overlay)
self.parent.wait_for_element_displayed(*DOM.Loop.wizard_login)
else:
cancel_btn = self.marionette.find_element(*DOM.Loop.form_confirm_cancel)
self.parent.wait_for_element_displayed(*DOM.Loop.settings_panel_header)
def switch_to_urls(self):
self.parent.wait_for_element_displayed(*DOM.Loop.call_log_shared_links_tab)
tab = self.marionette.find_element(*DOM.Loop.call_log_shared_links_tab)
tab.tap()
self.parent.wait_for_condition(lambda m: tab.get_attribute(
"aria-selected") == "true", timeout=10, message="Checking that 'Shared links' is selected")
def _get_number_of_urls(self, locator):
try:
entries = self.marionette.find_elements(*locator)
return len(entries)
except:
return 0
def get_number_of_all_urls(self):
return self._get_number_of_urls(DOM.Loop.shared_links_entry)
def get_number_of_available_urls(self):
return self._get_number_of_urls(DOM.Loop.shared_links_entry_available)
def get_number_of_revoked_urls(self):
return self._get_number_of_urls(DOM.Loop.shared_links_entry_revoked)
def _select_action(self, action):
elem = (DOM.Loop.form_action_action[0], DOM.Loop.form_action_action[1].format(action))
self.parent.wait_for_element_displayed(*elem)
self.marionette.find_element(*elem).tap()
def _confirm(self, decission):
elem = DOM.Loop.form_confirm_delete if decission else DOM.Loop.form_confirm_cancel
self.parent.wait_for_element_displayed(*elem)
self.marionette.find_element(*elem).tap()
def _is_entry_revoked(self, entry):
try:
entry.find_element(*DOM.Loop.shared_links_entry_revoked_nested)
return True
except Exception, e:
self.UTILS.reporting.logResult('info', "What happened here? {}".format(e))
return False
