def test_browser_bookmark(self):
# https://github.com/mozilla/gaia-ui-tests/issues/452
browser = Browser(self.marionette)
browser.launch()
browser.go_to_url('http://mozqa.com/data/firefox/layout/mozilla.html')
browser.tap_bookmark_button()
browser.tap_add_bookmark_to_home_screen_choice_button()
browser.type_bookmark_title(self.bookmark_title)
browser.dismiss_keyboard()
browser.tap_add_bookmark_to_home_screen_dialog_button()
# Switch to Home Screen to look for bookmark
homescreen = Homescreen(self.marionette)
self.marionette.execute_script(
"window.wrappedJSObject.dispatchEvent(new Event('home'));")
homescreen.switch_to_homescreen_frame()
self._bookmark_added = homescreen.is_app_installed(self.bookmark_title)
self.assertTrue(
self._bookmark_added,
'The bookmark %s was not found to be installed on the home screen.'
% self.bookmark_title)
class TestBrowserSearch(GaiaMtbfTestCase):
_google_search_input_locator = (By.NAME, 'q')
def setUp(self):
GaiaMtbfTestCase.setUp(self)
self.connect_to_network()
self.browser = Browser(self.marionette)
self.browser.launch()
def test_browser_search(self):
search_text = 'Mozilla Web QA'
self.wait_for_element_displayed(*self.browser._awesome_bar_locator)
self.marionette.find_element(
*self.browser._awesome_bar_locator).clear()
self.browser.go_to_url(search_text)
self.browser.switch_to_content()
self.wait_for_element_displayed(*self._google_search_input_locator)
self.assertTrue(search_text in self.marionette.title)
self.assertEqual(
search_text,
self.marionette.find_element(
*self._google_search_input_locator).get_attribute('value'))
def tearDown(self):
GaiaMtbfTestCase.tearDown(self)
def test_browser_tabs(self):
""" Open a new tab.
Open Browser.
Open tab menu.
Add a new tab.
Assert that the new tab has opened.
Load a website.
Switch back to the first tab.
"""
browser = Browser(self.marionette)
browser.launch()
# Open tab menu.
browser.tap_tab_badge_button()
# Add a new tab and load a website.
browser.tap_add_new_tab_button()
browser.go_to_url(self.test_url)
browser.switch_to_content()
Wait(self.marionette).until(lambda m: m.title == 'Mozilla')
# Assert that the new tab has opened.
browser.switch_to_chrome()
self.assertEqual(browser.displayed_tabs_number, 2)
# Assert that the displayed tabs number is equal with the actual number of opened tabs.
self.assertEqual(browser.displayed_tabs_number, browser.tabs_count)
# Switch back to the first tab.
browser.tap_tab_badge_button()
browser.tabs[0].tap_tab()
self.assertTrue(browser.is_awesome_bar_visible)
def test_browser_back_button(self):
browser = Browser(self.marionette)
browser.launch()
browser.go_to_url("http://mozqa.com/data/firefox/layout/mozilla.html")
browser.switch_to_content()
self.verify_home_page()
community_link = self.marionette.find_element(*self._community_link_locator)
# TODO: remove the explicit scroll once bug 833370 is fixed
self.marionette.execute_script("arguments[0].scrollIntoView(false);", [community_link])
community_link.tap()
self.verify_community_page()
browser.switch_to_chrome()
browser.tap_back_button()
browser.switch_to_content()
self.verify_home_page()
browser.switch_to_chrome()
browser.tap_forward_button()
browser.switch_to_content()
self.verify_community_page()
def test_browser_tabs(self):
""" Open a new tab.
Open Browser.
Open tab menu.
Add a new tab.
Assert that the new tab has opened.
Load a website.
Switch back to the first tab.
"""
browser = Browser(self.marionette)
browser.launch()
# Open tab menu.
browser.tap_tab_badge_button()
# Add a new tab and load a website.
browser.tap_add_new_tab_button()
browser.go_to_url(self.test_url)
browser.switch_to_content()
Wait(self.marionette).until(lambda m: m.title == 'Mozilla')
# Assert that the new tab has opened.
browser.switch_to_chrome()
self.assertEqual(browser.displayed_tabs_number, 2)
# Assert that the displayed tabs number is equal with the actual number of opened tabs.
self.assertEqual(browser.displayed_tabs_number, browser.tabs_count)
# Switch back to the first tab.
browser.tap_tab_badge_button()
browser.tabs[0].tap_tab()
self.assertTrue(browser.is_awesome_bar_visible)
def test_browser_lan(self):
"""https://moztrap.mozilla.org/manage/case/1327/"""
browser = Browser(self.marionette)
browser.launch()
browser.go_to_url(self.test_url)
browser.switch_to_content()
Wait(self.marionette).until(lambda m: m.title == 'Mozilla')
def test_cost_control_reset_wifi(self):
self.data_layer.connect_to_wifi()
cost_control = CostControl(self.marionette)
cost_control.launch()
cost_control.run_ftu_accepting_defaults()
cost_control.toggle_mobile_data_tracking(False)
cost_control.toggle_wifi_data_tracking(True)
# open browser to get some data downloaded
# please remove this once there is a better way than launching browser app/obj to do so
browser = Browser(self.marionette)
browser.launch()
browser.go_to_url('http://mozqa.com/data/firefox/layout/mozilla.html')
browser.switch_to_content()
self.wait_for_element_present(*self._page_title_locator)
# go back to Cost Control
cost_control.launch()
# if we can't trigger any data usage, there must be something wrong
self.assertNotEqual(cost_control.wifi_data_usage_figure, u'0.00 B', 'No data usage shown after browsing.')
# disable wifi before reset data, wait for wifi to be closed, and switch back to the app
self.data_layer.disable_wifi()
time.sleep(1)
cost_control.launch()
# # go to settings section
settings = cost_control.tap_settings()
settings.reset_data_usage()
settings.tap_done()
# wait for usage to be refreshed
self.wait_for_condition(lambda m: cost_control.wifi_data_usage_figure == u'0.00 B', message='Wifi usage did not reset back to 0.00 B')
def test_browser_bookmark(self):
# https://github.com/mozilla/gaia-ui-tests/issues/452
browser = Browser(self.marionette)
browser.launch()
browser.go_to_url('http://mozqa.com/data/firefox/layout/mozilla.html')
browser.tap_bookmark_button()
browser.tap_add_bookmark_to_home_screen_choice_button()
browser.type_bookmark_title(self.bookmark_title)
browser.tap_add_bookmark_to_home_screen_dialog_button()
# Switch to Home Screen to look for bookmark
self.marionette.switch_to_frame()
self.marionette.execute_script("window.wrappedJSObject.dispatchEvent(new Event('home'));")
self.marionette.switch_to_frame(self.marionette.find_element(*self._homescreen_frame_locator))
# Wait for Gaia to insert the element into the page
self.wait_for_element_present(*self._homescreen_icon_locator)
# check whether bookmark was added
while self._homescreen_has_more_pages:
if self.is_element_displayed(*self._homescreen_icon_locator):
self._bookmark_added = True
break
self._go_to_next_page()
self.assertTrue(self._bookmark_added, 'The bookmark %s was not found to be installed on the home screen.' % self.bookmark_title)
def test_persona_cookie(self):
"""
Smoketest of cookie handling/Persona integration
Log in with Persona user
After refreshing 123done should still be logged in (cookie retained)
"""
browser = Browser(self.marionette)
browser.launch()
browser.go_to_url('http://firefoxos.123done.org')
browser.switch_to_content()
self.wait_for_element_displayed(*self._logged_out_button_locator, timeout=120)
login_button = self.marionette.find_element(*self._logged_out_button_locator)
login_button.click()
persona = Persona(self.marionette)
persona.login(self.user.email, self.user.password)
# wait to fall back to browser
self.wait_for_condition(lambda m: self.apps.displayed_app.name == browser.name)
self.apps.switch_to_displayed_app()
browser.switch_to_content()
self.wait_for_element_displayed(*self._logged_in_button_locator)
browser.switch_to_chrome()
# Refresh the page
browser.tap_go_button()
# Now we expect B2G to retain the Persona cookie and remain logged in
browser.switch_to_content()
self.wait_for_element_displayed(*self._logged_in_button_locator)
def test_play_youtube_video(self):
""" Confirm YouTube video playback
https://moztrap.mozilla.org/manage/case/6073/
"""
browser = Browser(self.marionette)
browser.launch()
browser.go_to_url(self.video_URL)
browser.switch_to_content()
# Tap the video
self.wait_for_element_present(*self._video_container_locator)
self.marionette.find_element(*self._video_container_locator).tap()
# TODO: Remove sleep when Bug # 815115 is addressed, or if we can wait for a Javascript condition
time.sleep(1)
self.marionette.switch_to_frame()
fullscreen_video = FullscreenVideo(self.marionette)
# Switch to video player
fullscreen_video.switch_to_video_frame()
# Check for playback
self.assertTrue(fullscreen_video.is_video_playing)
class TestBrowserCellData(GaiaMtbfTestCase):
_page_title_locator = (By.ID, 'page-title')
def setUp(self):
GaiaMtbfTestCase.setUp(self)
self.data_layer = GaiaData(self.marionette)
self.data_layer.connect_to_cell_data()
self.browser = Browser(self.marionette)
self.browser.launch()
def test_browser_cell_data(self):
"""https://moztrap.mozilla.org/manage/case/1328/"""
self.wait_for_element_displayed(*self.browser._awesome_bar_locator)
self.marionette.find_element(
*self.browser._awesome_bar_locator).clear()
self.browser.go_to_url(
'http://mozqa.com/data/firefox/layout/mozilla.html', timeout=120)
self.browser.switch_to_content()
self.wait_for_element_present(*self._page_title_locator, timeout=120)
heading = self.marionette.find_element(*self._page_title_locator)
self.assertEqual(
heading.text,
'We believe that the internet should be public, open and accessible.'
)
def tearDown(self):
self.data_layer.disable_cell_data()
GaiaMtbfTestCase.tearDown(self)
def test_browser_back_button(self):
# https://github.com/mozilla/gaia-ui-tests/issues/450
browser = Browser(self.marionette)
browser.launch()
browser.go_to_url('http://mozqa.com/data/firefox/layout/mozilla.html')
browser.switch_to_content()
self.verify_home_page()
community_link = self.marionette.find_element(*self._community_link_locator)
community_link.tap()
# # TODO: remove this execute_script when bug 833370 has been fixed
# self.marionette.execute_script("arguments[0].scrollIntoView(false);", [community_link])
# self.marionette.tap(community_link)
self.verify_community_page()
browser.switch_to_chrome()
browser.tap_back_button()
browser.switch_to_content()
self.verify_home_page()
browser.switch_to_chrome()
browser.tap_forward_button()
browser.switch_to_content()
self.verify_community_page()
class TestBrowserSearch(GaiaMtbfTestCase):
_google_search_input_locator = (By.NAME, 'q')
def setUp(self):
GaiaMtbfTestCase.setUp(self)
self.connect_to_network()
self.browser = Browser(self.marionette)
self.browser.launch()
def test_browser_search(self):
search_text = 'Mozilla Web QA'
self.wait_for_element_displayed(*self.browser._awesome_bar_locator)
self.marionette.find_element(*self.browser._awesome_bar_locator).clear()
self.browser.go_to_url(search_text)
self.browser.switch_to_content()
self.wait_for_element_displayed(*self._google_search_input_locator)
self.assertTrue(search_text in self.marionette.title)
self.assertEqual(search_text,
self.marionette.find_element(*self._google_search_input_locator).get_attribute('value'))
def tearDown(self):
GaiaMtbfTestCase.tearDown(self)
def test_browser_back_button(self):
# https://github.com/mozilla/gaia-ui-tests/issues/450
browser = Browser(self.marionette)
browser.launch()
browser.go_to_url('http://mozqa.com/data/firefox/layout/mozilla.html')
browser.switch_to_content()
self.verify_home_page()
community_link = self.marionette.find_element(*self._community_link_locator)
# TODO: remove the explicit scroll once bug 833370 is fixed
self.marionette.execute_script("arguments[0].scrollIntoView(false);", [community_link])
community_link.tap()
self.verify_community_page()
browser.switch_to_chrome()
browser.tap_back_button()
browser.switch_to_content()
self.verify_home_page()
browser.switch_to_chrome()
browser.tap_forward_button()
browser.switch_to_content()
self.verify_community_page()
def test_play_youtube_video(self):
""" Confirm YouTube video playback
https://moztrap.mozilla.org/manage/case/6073/
"""
browser = Browser(self.marionette)
browser.launch()
browser.go_to_url(self.video_URL)
browser.switch_to_content()
# Tap the video
self.wait_for_element_present(*self._video_container_locator)
self.marionette.find_element(*self._video_container_locator).tap()
# TODO: Remove sleep when Bug # 815115 is addressed, or if we can wait for a Javascript condition
time.sleep(1)
self.marionette.switch_to_frame()
fullscreen_video = FullscreenVideo(self.marionette)
# Switch to video player
fullscreen_video.switch_to_video_frame()
# Check for playback
self.assertTrue(fullscreen_video.is_video_playing)
def test_browser_bookmark(self):
# https://github.com/mozilla/gaia-ui-tests/issues/452
browser = Browser(self.marionette)
browser.launch()
browser.go_to_url('http://mozqa.com/data/firefox/layout/mozilla.html')
browser.tap_bookmark_button()
browser.tap_add_bookmark_to_home_screen_choice_button()
browser.type_bookmark_title(self.bookmark_title)
browser.tap_add_bookmark_to_home_screen_dialog_button()
# Switch to Home Screen to look for bookmark
self.marionette.switch_to_frame()
self.marionette.execute_script("window.wrappedJSObject.dispatchEvent(new Event('home'));")
self.marionette.switch_to_frame(self.marionette.find_element(*self._homescreen_frame_locator))
# Wait for Gaia to insert the element into the page
self.wait_for_element_present(*self._homescreen_icon_locator)
# check whether bookmark was added
while self._homescreen_has_more_pages:
if self.is_element_displayed(*self._homescreen_icon_locator):
self._bookmark_added = True
break
self._go_to_next_page()
self.assertTrue(self._bookmark_added, 'The bookmark %s was not found to be installed on the home screen.' % self.bookmark_title)
def test_browser_lan(self):
"""https://moztrap.mozilla.org/manage/case/1327/"""
browser = Browser(self.marionette)
browser.launch()
browser.go_to_url(self.test_url)
browser.switch_to_content()
Wait(self.marionette).until(lambda m: m.title == 'Mozilla')
def browser_cell(self):
# Start browser and load page and verify, code taken from test_browser_cell_data.py
browser = Browser(self.marionette)
browser.launch()
browser.go_to_url('http://mozqa.com/data/firefox/layout/mozilla.html',
timeout=120)
browser.switch_to_content()
self.wait_for_element_present(*self._page_title_locator, timeout=120)
heading = self.marionette.find_element(*self._page_title_locator)
self.assertEqual(
heading.text,
'We believe that the internet should be public, open and accessible.'
)
# Wait a couple of seconds with page displayed
time.sleep(2)
# Close the browser using home button
self.app = browser
self.close_app()
# Sleep between iterations
time.sleep(10)
class TestBrowserCellData(GaiaMtbfTestCase):
_page_title_locator = (By.ID, 'page-title')
def setUp(self):
GaiaMtbfTestCase.setUp(self)
self.data_layer = GaiaData(self.marionette)
self.data_layer.connect_to_cell_data()
self.browser = Browser(self.marionette)
self.browser.launch()
def test_browser_cell_data(self):
"""https://moztrap.mozilla.org/manage/case/1328/"""
self.wait_for_element_displayed(*self.browser._awesome_bar_locator)
self.marionette.find_element(*self.browser._awesome_bar_locator).clear()
self.browser.go_to_url('http://mozqa.com/data/firefox/layout/mozilla.html', timeout=120)
self.browser.switch_to_content()
self.wait_for_element_present(*self._page_title_locator, timeout=120)
heading = self.marionette.find_element(*self._page_title_locator)
self.assertEqual(heading.text, 'We believe that the internet should be public, open and accessible.')
def tearDown(self):
self.data_layer.disable_cell_data()
GaiaMtbfTestCase.tearDown(self)
def test_browser_tabs(self):
""" Open a new tab.
Using Wifi/LAN
Open Browser.
Open tab menu.
Add a new tab.
Assert that the new tab has opened.
Load a website ( http://mozqa.com/data/firefox/layout/mozilla.html)
Switch back to the first tab.
"""
browser = Browser(self.marionette)
browser.launch()
# Open tab menu.
browser.tap_tab_badge_button()
# Add a new tab and load a website.
browser.tap_add_new_tab_button()
browser.go_to_url('http://mozqa.com/data/firefox/layout/mozilla.html')
browser.switch_to_content()
self.wait_for_element_present(*self._page_title_locator)
heading = self.marionette.find_element(*self._page_title_locator)
self.assertEqual(heading.text, 'We believe that the internet should be public, open and accessible.')
# Assert that the new tab has opened.
browser.switch_to_chrome()
self.assertEqual(browser.displayed_tabs_number, 2)
# Assert that the displayed tabs number is equal with the actual number of opened tabs.
self.assertEqual(browser.displayed_tabs_number, browser.tabs_count)
# Switch back to the first tab.
browser.tap_tab_badge_button()
browser.tabs[0].tap_tab()
self.assertTrue(browser.is_awesome_bar_visible)
class TestBrowserNavigation(GaiaMtbfTestCase):
_community_link_locator = (By.CSS_SELECTOR, '#community a')
_community_history_section_locator = (By.ID, 'history')
def setUp(self):
GaiaMtbfTestCase.setUp(self)
self.connect_to_network()
self.browser = Browser(self.marionette)
self.browser.launch()
def test_browser_back_button(self):
self.wait_for_element_displayed(*self.browser._awesome_bar_locator)
self.marionette.find_element(
*self.browser._awesome_bar_locator).clear()
self.browser.go_to_url(
'http://mozqa.com/data/firefox/layout/mozilla.html')
self.browser.switch_to_content()
self.verify_home_page()
community_link = self.marionette.find_element(
*self._community_link_locator)
# TODO: remove the explicit scroll once bug 833370 is fixed
self.marionette.execute_script("arguments[0].scrollIntoView(false);",
[community_link])
community_link.tap()
self.verify_community_page()
self.browser.switch_to_chrome()
self.browser.tap_back_button()
self.browser.switch_to_content()
self.verify_home_page()
self.browser.switch_to_chrome()
self.browser.tap_forward_button()
self.browser.switch_to_content()
self.verify_community_page()
def verify_home_page(self):
self.wait_for_element_present(*self._community_link_locator)
community_link = self.marionette.find_element(
*self._community_link_locator)
self.assertTrue(community_link.is_displayed(),
'The community link was not visible at mozilla.html.')
def verify_community_page(self):
self.wait_for_element_present(*self._community_history_section_locator)
history_section = self.marionette.find_element(
*self._community_history_section_locator)
self.assertTrue(
history_section.is_displayed(),
'The history section was not visible at mozilla_community.html.')
def tearDown(self):
GaiaMtbfTestCase.tearDown(self)
def prepare_app(self, app_name):
if app_name.lower() == 'browser':
from gaiatest.apps.browser.app import Browser
browser = Browser(self.marionette)
browser.go_to_url('http://taskjs.org/')
tab_frame = self.marionette.execute_script("return window.wrappedJSObject.Browser.currentTab.dom;")
self.marionette.switch_to_frame(tab_frame)
MarionetteWait(self.marionette, 30).until(lambda m: m.execute_script('return window.document.readyState;', new_sandbox=False) == 'complete')
def before_scroll(self):
B2GPerfScrollTest.before_scroll(self)
from gaiatest.apps.browser.app import Browser
app = Browser(self.marionette)
app.go_to_url('http://taskjs.org/')
# TODO Move readyState wait into app object
app.switch_to_content()
MarionetteWait(self.marionette, 30).until(
lambda m: m.execute_script(
'return window.document.readyState;',
new_sandbox=False) == 'complete')
def test_browser_lan(self):
# https://moztrap.mozilla.org/manage/case/1327/
browser = Browser(self.marionette)
browser.launch()
browser.go_to_url('http://mozqa.com/data/firefox/layout/mozilla.html')
browser.switch_to_content()
self.wait_for_element_present(*self._page_title_locator)
heading = self.marionette.find_element(*self._page_title_locator)
self.assertEqual(heading.text, 'We believe that the internet should be public, open and accessible.')
class TestBrowserBookmark(GaiaMtbfTestCase):
_bookmark_added = False
def setUp(self):
GaiaMtbfTestCase.setUp(self)
self.connect_to_network()
self.test_url = 'http://mozqa.com/data/firefox/layout/mozilla.html'
curr_time = repr(time.time()).replace('.', '')
self.bookmark_title = 'gaia%s' % curr_time[10:]
self.homescreen = Homescreen(self.marionette)
self.browser = Browser(self.marionette)
self.browser.launch()
def test_browser_bookmark(self):
self.wait_for_element_displayed(*self.browser._awesome_bar_locator)
self.marionette.find_element(*self.browser._awesome_bar_locator).clear()
self.browser.go_to_url(self.test_url)
self.browser.tap_bookmark_button()
bookmark = self.browser.tap_add_bookmark_to_home_screen_choice_button()
self.wait_for_element_displayed(*bookmark._bookmark_title_input_locator)
bookmark.type_bookmark_title(self.bookmark_title)
bookmark.tap_add_bookmark_to_home_screen_dialog_button()
# Switch to Home Screen to look for bookmark
self.device.touch_home_button()
self.wait_for_element_displayed('id', 'bookmark-title')
self.homescreen.wait_for_app_icon_present(self.bookmark_title)
self._bookmark_added = self.homescreen.is_app_installed(self.bookmark_title)
if self.find_element('id', 'edit-button').is_displayed():
self.find_element('id', 'edit-button').tap()
self.assertTrue(self._bookmark_added, 'The bookmark %s was not found to be installed on the home screen.' % self.bookmark_title)
def tearDown(self):
# make sure it goes back to the top for activating editing mode
self.device.touch_home_button()
self.device.touch_home_button()
# delete the bookmark
self.apps.switch_to_displayed_app()
self.homescreen.activate_edit_mode()
self.confirm_dialog = self.homescreen.installed_app(self.bookmark_title).tap_delete_app()
self.confirm_dialog.tap_confirm()
self.data_layer.disable_wifi()
GaiaMtbfTestCase.tearDown(self)
class TestYouTube(GaiaMtbfTestCase):
video_URL = 'http://m.youtube.com/watch?v=5MzuGWFIfio'
acceptable_delay = 2.0
# YouTube video locators
_video_container_locator = (By.CSS_SELECTOR, 'div[style^="background-image"]')
_video_element_locator = (By.TAG_NAME, 'video')
def setUp(self):
GaiaMtbfTestCase.setUp(self)
self.connect_to_network()
self.browser = Browser(self.marionette)
self.browser.launch()
def test_play_youtube_video(self):
"""Confirm YouTube video playback
https://moztrap.mozilla.org/manage/case/6073/
"""
self.wait_for_element_displayed(*self.browser._awesome_bar_locator)
self.marionette.find_element(*self.browser._awesome_bar_locator).clear()
self.browser.go_to_url(self.video_URL, timeout=180)
self.browser.switch_to_content()
# Tap the video container to load the <video> element and start playing
self.wait_for_element_displayed(*self._video_container_locator)
self.marionette.find_element(*self._video_container_locator).tap()
# Wait HTML5 player to appear
self.wait_for_element_displayed(*self._video_element_locator)
video = self.marionette.find_element(*self._video_element_locator)
player = HTML5Player(self.marionette, video)
# Check that video is playing
player.wait_for_video_loaded()
self.assertTrue(player.is_video_playing())
# Pause playback
player.pause()
stopped_at = player.current_timestamp
self.assertFalse(player.is_video_playing())
# Resume playback
player.play()
resumed_at = player.current_timestamp
self.assertTrue(player.is_video_playing())
def tearDown(self):
self.data_layer.disable_wifi()
GaiaMtbfTestCase.tearDown(self)
def test_browser_search(self):
browser = Browser(self.marionette)
browser.launch()
search_text = 'Mozilla Web QA'
browser.go_to_url(search_text)
browser.switch_to_content()
self.wait_for_element_displayed(*self._google_search_input_locator)
self.assertTrue(search_text in self.marionette.title)
self.assertEqual(search_text,
self.marionette.find_element(*self._google_search_input_locator).get_attribute('value'))
def test_browser_search(self):
# https://github.com/mozilla/gaia-ui-tests/issues/451
browser = Browser(self.marionette)
browser.launch()
search_text = 'Mozilla Web QA'
browser.go_to_url(search_text)
browser.switch_to_content()
self.wait_for_element_displayed(*self._bing_search_input_locator)
self.assertEqual('Bing : %s' % search_text, self.marionette.title)
self.assertEqual(search_text,
self.marionette.find_element(*self._bing_search_input_locator).get_attribute('value'))
def test_browser_keyboard(self):
# This test runs on TBPL only because other tests cover it on device
browser = Browser(self.marionette)
browser.launch()
search_url = 'http://mozqa.com/data/firefox/layout/mozilla.html'
browser.go_to_url(search_url)
search_src = browser.url_src
# Assert that the typed url is the same as the src attribute of the browser iframe
self.assertEqual(search_url, search_src)
def test_browser_search(self):
# https://github.com/mozilla/gaia-ui-tests/issues/451
browser = Browser(self.marionette)
browser.launch()
search_text = 'Mozilla Web QA'
browser.go_to_url(search_text)
browser.switch_to_content()
self.wait_for_element_displayed(*self._bing_search_input_locator)
self.assertEqual('Bing : %s' % search_text, self.marionette.title)
self.assertEqual(search_text,
self.marionette.find_element(*self._bing_search_input_locator).get_attribute('value'))
def test_browser_search(self):
browser = Browser(self.marionette)
browser.launch()
search_text = 'Mozilla Web QA'
browser.go_to_url(search_text)
browser.switch_to_content()
self.wait_for_element_displayed(*self._google_search_input_locator)
self.assertTrue(search_text in self.marionette.title)
self.assertEqual(
search_text,
self.marionette.find_element(
*self._google_search_input_locator).get_attribute('value'))
class TestBrowserTabs(GaiaMtbfTestCase):
_page_title_locator = (By.ID, 'page-title')
def setUp(self):
GaiaMtbfTestCase.setUp(self)
self.connect_to_network()
self.browser = Browser(self.marionette)
self.browser.launch()
def test_browser_tabs(self):
# Remember the tabs number
self.ori_tab_num = self.browser.displayed_tabs_number
# Open tab menu.
self.browser.tap_tab_badge_button()
# Add a new tab and load a website.
self.browser.tap_add_new_tab_button()
self.browser.go_to_url(
'http://mozqa.com/data/firefox/layout/mozilla.html')
self.browser.switch_to_content()
self.wait_for_element_present(*self._page_title_locator)
heading = self.marionette.find_element(*self._page_title_locator)
self.assertEqual(
heading.text,
'We believe that the internet should be public, open and accessible.'
)
# Assert that the new tab has opened.
self.browser.switch_to_chrome()
self.assertEqual(self.browser.displayed_tabs_number,
self.ori_tab_num + 1)
# Assert that the displayed tabs number is equal with the actual number of opened tabs.
self.assertEqual(self.browser.displayed_tabs_number,
self.browser.tabs_count)
# Switch back to the first tab.
self.browser.tap_tab_badge_button()
self.browser.tabs[0].tap_tab()
self.assertTrue(self.browser.is_awesome_bar_visible)
def tearDown(self):
self.data_layer.disable_wifi()
GaiaMtbfTestCase.tearDown(self)
def test_browser_bookmark(self):
browser = Browser(self.marionette)
browser.launch()
browser.go_to_url('http://mozqa.com/data/firefox/layout/mozilla.html')
browser.tap_bookmark_button()
bookmark = browser.tap_add_bookmark_to_home_screen_choice_button()
bookmark.type_bookmark_title(self.bookmark_title)
bookmark.tap_add_bookmark_to_home_screen_dialog_button()
# Switch to Home Screen to look for bookmark
self.device.touch_home_button()
homescreen = Homescreen(self.marionette)
self._bookmark_added = homescreen.is_app_installed(self.bookmark_title)
self.assertTrue(self._bookmark_added, 'The bookmark %s was not found to be installed on the home screen.' % self.bookmark_title)
def test_cost_control_data_alert_mobile(self):
"""https://moztrap.mozilla.org/manage/case/8938/"""
cost_control = CostControl(self.marionette)
cost_control.launch()
cost_control.switch_to_ftu()
cost_control.run_ftu_accepting_defaults()
self.assertTrue(cost_control.is_mobile_data_tracking_on)
self.assertFalse(cost_control.is_wifi_data_tracking_on)
settings = cost_control.tap_settings()
settings.toggle_data_alert_switch(True)
settings.select_when_use_is_above_unit_and_value(u'MB', '0.1')
settings.reset_mobile_usage()
settings.tap_done()
self.assertTrue(cost_control.is_mobile_data_tracking_on)
# open browser to get some data downloaded
browser = Browser(self.marionette)
browser.launch()
browser.go_to_url('http://www.mozilla.org/', timeout=180)
browser.switch_to_content()
self.wait_for_condition(
lambda m: "Home of the Mozilla Project" in m.title)
browser.switch_to_chrome()
# get the notification bar
self.device.touch_home_button()
self.marionette.switch_to_frame()
self.marionette.execute_script(
"window.wrappedJSObject.UtilityTray.show()")
# switch to cost control widget
usage_iframe = self.marionette.find_element(
*self._cost_control_widget_locator)
self.marionette.switch_to_frame(usage_iframe)
# make sure the color changed
self.wait_for_condition(
lambda m: 'reached-limit' in self.marionette.find_element(
*self._data_usage_view_locator).get_attribute('class'),
message='Data usage bar did not breach limit')
def test_browser_bookmark(self):
browser = Browser(self.marionette)
browser.launch()
browser.go_to_url('http://mozqa.com/data/firefox/layout/mozilla.html')
browser.tap_bookmark_button()
bookmark = browser.tap_add_bookmark_to_home_screen_choice_button()
bookmark.switch_to_add_bookmark_frame()
bookmark.type_bookmark_title(self.bookmark_title)
bookmark.tap_add_bookmark_to_home_screen_dialog_button()
# Switch to Home Screen to look for bookmark
self.device.touch_home_button()
homescreen = Homescreen(self.marionette)
self._bookmark_added = homescreen.is_app_installed(self.bookmark_title)
self.assertTrue(self._bookmark_added, 'The bookmark %s was not found to be installed on the home screen.' % self.bookmark_title)
def test_browser_bookmark(self):
# https://github.com/mozilla/gaia-ui-tests/issues/452
browser = Browser(self.marionette)
browser.launch()
browser.go_to_url('http://mozqa.com/data/firefox/layout/mozilla.html')
browser.tap_bookmark_button()
browser.tap_add_bookmark_to_home_screen_choice_button()
browser.type_bookmark_title(self.bookmark_title)
browser.tap_add_bookmark_to_home_screen_dialog_button()
# Switch to Home Screen to look for bookmark
homescreen = Homescreen(self.marionette)
self.marionette.execute_script("window.wrappedJSObject.dispatchEvent(new Event('home'));")
homescreen.switch_to_homescreen_frame()
self._bookmark_added = homescreen.is_app_installed(self.bookmark_title)
self.assertTrue(self._bookmark_added, 'The bookmark %s was not found to be installed on the home screen.' % self.bookmark_title)
def test_cost_control_data_alert_mobile(self):
"""https://moztrap.mozilla.org/manage/case/8938/"""
cost_control = CostControl(self.marionette)
cost_control.launch()
cost_control.switch_to_ftu()
cost_control.run_ftu_accepting_defaults()
self.assertTrue(cost_control.is_mobile_data_tracking_on)
self.assertFalse(cost_control.is_wifi_data_tracking_on)
settings = cost_control.tap_settings()
settings.toggle_data_alert_switch(True)
settings.select_when_use_is_above_unit_and_value(u'MB', '0.1')
settings.reset_mobile_usage()
settings.tap_done()
self.assertTrue(cost_control.is_mobile_data_tracking_on)
# open browser to get some data downloaded
browser = Browser(self.marionette)
browser.launch()
browser.go_to_url('http://www.mozilla.org/', timeout=180)
browser.switch_to_content()
self.wait_for_condition(lambda m: "Home of the Mozilla Project" in m.title)
browser.switch_to_chrome()
# get the notification bar
self.device.touch_home_button()
self.marionette.switch_to_frame()
self.marionette.execute_script("window.wrappedJSObject.UtilityTray.show()")
# switch to cost control widget
usage_iframe = self.marionette.find_element(*self._cost_control_widget_locator)
self.marionette.switch_to_frame(usage_iframe)
# make sure the color changed
self.wait_for_condition(
lambda m: 'reached-limit' in self.marionette.find_element(
*self._data_usage_view_locator).get_attribute('class'),
message='Data usage bar did not breach limit')
def test_browser_bookmark(self):
browser = Browser(self.marionette)
browser.launch()
browser.go_to_url(self.test_url)
browser.tap_bookmark_button()
bookmark = browser.tap_add_bookmark_to_home_screen_choice_button()
bookmark.type_bookmark_title(self.bookmark_title)
bookmark.tap_add_bookmark_to_home_screen_dialog_button()
# Switch to Home Screen to look for bookmark
self.device.touch_home_button()
homescreen = Homescreen(self.marionette)
self._bookmark_added = homescreen.is_app_installed(self.bookmark_title)
self.assertTrue(
self._bookmark_added,
'The bookmark %s was not found to be installed on the home screen.'
% self.bookmark_title)
def test_cost_control_reset_wifi(self):
self.data_layer.connect_to_wifi()
cost_control = CostControl(self.marionette)
cost_control.launch()
cost_control.switch_to_ftu()
cost_control.run_ftu_accepting_defaults()
cost_control.toggle_mobile_data_tracking(False)
cost_control.toggle_wifi_data_tracking(True)
# open browser to get some data downloaded
# please remove this once there is a better way than launching browser app/obj to do so
browser = Browser(self.marionette)
browser.launch()
browser.go_to_url('http://mozqa.com/data/firefox/layout/mozilla.html')
browser.switch_to_content()
self.wait_for_element_present(*self._page_title_locator)
# go back to Cost Control
cost_control.launch()
# if we can't trigger any data usage, there must be something wrong
self.assertNotEqual(cost_control.wifi_data_usage_figure, u'0.00 B',
'No data usage shown after browsing.')
# disable wifi before reset data, wait for wifi to be closed, and switch back to the app
self.data_layer.disable_wifi()
time.sleep(1)
cost_control.launch()
# # go to settings section
settings = cost_control.tap_settings()
settings.reset_data_usage()
settings.tap_done()
# wait for usage to be refreshed
self.wait_for_condition(
lambda m: cost_control.wifi_data_usage_figure == u'0.00 B',
message='Wifi usage did not reset back to 0.00 B')
class TestBrowserTabs(GaiaMtbfTestCase):
_page_title_locator = (By.ID, 'page-title')
def setUp(self):
GaiaMtbfTestCase.setUp(self)
self.connect_to_network()
self.browser = Browser(self.marionette)
self.browser.launch()
def test_browser_tabs(self):
# Remember the tabs number
self.ori_tab_num = self.browser.displayed_tabs_number
# Open tab menu.
self.browser.tap_tab_badge_button()
# Add a new tab and load a website.
self.browser.tap_add_new_tab_button()
self.browser.go_to_url('http://mozqa.com/data/firefox/layout/mozilla.html')
self.browser.switch_to_content()
self.wait_for_element_present(*self._page_title_locator)
heading = self.marionette.find_element(*self._page_title_locator)
self.assertEqual(heading.text, 'We believe that the internet should be public, open and accessible.')
# Assert that the new tab has opened.
self.browser.switch_to_chrome()
self.assertEqual(self.browser.displayed_tabs_number, self.ori_tab_num + 1)
# Assert that the displayed tabs number is equal with the actual number of opened tabs.
self.assertEqual(self.browser.displayed_tabs_number, self.browser.tabs_count)
# Switch back to the first tab.
self.browser.tap_tab_badge_button()
self.browser.tabs[0].tap_tab()
self.assertTrue(self.browser.is_awesome_bar_visible)
def tearDown(self):
self.data_layer.disable_wifi()
GaiaMtbfTestCase.tearDown(self)
def browser_wifi(self):
# Start browser and load page and verify, code taken from test_browser_cell_data.py
browser = Browser(self.marionette)
browser.launch()
browser.go_to_url('http://mozqa.com/data/firefox/layout/mozilla.html')
browser.switch_to_content()
self.wait_for_element_present(*self._page_title_locator, timeout=120)
heading = self.marionette.find_element(*self._page_title_locator)
self.assertEqual(heading.text, 'We believe that the internet should be public, open and accessible.')
# Wait a couple of seconds with page displayed
time.sleep(2)
# Close the browser using home button
self.app = browser
self.close_app()
# Sleep between iterations
time.sleep(10)
def test_browser_bookmark(self):
browser = Browser(self.marionette)
browser.launch()
browser.go_to_url(self.test_url)
browser.tap_bookmark_button()
bookmark = browser.tap_add_bookmark_to_home_screen_choice_button()
bookmark.type_bookmark_title(self.bookmark_title)
bookmark.tap_add_bookmark_to_home_screen_dialog_button()
# Switch to Home Screen to look for bookmark
self.device.touch_home_button()
homescreen = Homescreen(self.marionette)
homescreen.wait_for_app_icon_present(self.bookmark_title)
self._bookmark_added = homescreen.is_app_installed(self.bookmark_title)
self.assertTrue(
self._bookmark_added,
"The bookmark %s was not found to be installed on the home screen." % self.bookmark_title,
)
def test_cost_control_data_alert_mobile(self):
self.data_layer.connect_to_cell_data()
cost_control = CostControl(self.marionette)
cost_control.launch()
cost_control.run_ftu_accepting_defaults()
self.assertTrue(cost_control.is_mobile_data_tracking_on)
self.assertFalse(cost_control.is_wifi_data_tracking_on)
settings = cost_control.tap_settings()
settings.toggle_data_alert_switch(True)
settings.select_when_use_is_above_unit_and_value('MB', '0.1')
settings.reset_data_usage()
settings.tap_done()
self.assertTrue(cost_control.is_mobile_data_tracking_on)
# open browser to get some data downloaded
# please remove this once there is a better way than launching browser app/obj to do so
browser = Browser(self.marionette)
browser.launch()
browser.go_to_url('http://developer.mozilla.org/')
browser.switch_to_content()
self.wait_for_element_present(*self._page_body_locator, timeout=120)
browser.switch_to_chrome()
# get the notification bar
self.marionette.switch_to_frame()
self.marionette.execute_script("window.wrappedJSObject.UtilityTray.show()")
# switch to cost control widget
usage_iframe = self.marionette.find_element(*self._cost_control_widget_locator)
self.marionette.switch_to_frame(usage_iframe)
# make sure the color changed
self.wait_for_condition(
lambda m: 'reached-limit' in self.marionette.find_element(*self._data_usage_view_locator).get_attribute('class'),
message='Data usage bar did not breach limit'
)
def test_browser_back_button(self):
# https://github.com/mozilla/gaia-ui-tests/issues/450
browser = Browser(self.marionette)
browser.launch()
browser.go_to_url('http://mozqa.com/data/firefox/layout/mozilla.html')
browser.switch_to_content()
self.verify_home_page()
self.marionette.tap(self.marionette.find_element(*self._community_link_locator))
self.verify_community_page()
browser.switch_to_chrome()
browser.tap_back_button()
browser.switch_to_content()
self.verify_home_page()
browser.switch_to_chrome()
browser.tap_forward_button()
browser.switch_to_content()
self.verify_community_page()
def test_play_youtube_video(self):
"""Confirm YouTube video playback
https://moztrap.mozilla.org/manage/case/6073/
"""
browser = Browser(self.marionette)
browser.launch()
browser.go_to_url(self.video_URL)
browser.switch_to_content()
# Tap the video container
self.wait_for_element_present(*self._video_container_locator)
self.marionette.find_element(*self._video_container_locator).tap()
# Wait HTML5 player to appear
self.wait_for_element_present(*self._video_element_locator)
video = self.marionette.find_element(*self._video_element_locator)
player = HTML5Player(self.marionette, video)
# Check that video is playing
player.wait_for_video_loaded()
self.assertTrue(player.is_video_playing())
# Pause playback
player.pause()
stopped_at = player.current_timestamp
self.assertFalse(player.is_video_playing())
# Resume playback
player.play()
resumed_at = player.current_timestamp
self.assertTrue(player.is_video_playing())
# Ensure that video resumes to play
# from the place where it was paused
delay = resumed_at - stopped_at
self.assertLessEqual(
delay, self.acceptable_delay,
'video resumed to play not from place where it was paused')
def test_browser_bookmark(self):
# https://github.com/mozilla/gaia-ui-tests/issues/452
browser = Browser(self.marionette)
browser.launch()
browser.go_to_url('http://mozqa.com/data/firefox/layout/mozilla.html')
browser.tap_bookmark_button()
browser.tap_add_bookmark_to_home_screen_choice_button()
browser.type_bookmark_title(self.bookmark_title)
browser.tap_add_bookmark_to_home_screen_dialog_button()
# Switch to Home Screen to look for bookmark
homescreen = Homescreen(self.marionette)
homescreen.touch_home_button()
self._bookmark_added = homescreen.is_app_installed(self.bookmark_title)
self.assertTrue(
self._bookmark_added,
'The bookmark %s was not found to be installed on the home screen.'
% self.bookmark_title)
def test_play_youtube_video(self):
"""Confirm YouTube video playback
https://moztrap.mozilla.org/manage/case/6073/
"""
browser = Browser(self.marionette)
browser.launch()
browser.go_to_url(self.video_URL, timeout=180)
browser.switch_to_content()
# Tap the video container to load the <video> element and start playing
self.wait_for_element_displayed(*self._video_container_locator)
self.marionette.find_element(*self._video_container_locator).tap()
# Wait HTML5 player to appear
self.wait_for_element_displayed(*self._video_element_locator)
video = self.marionette.find_element(*self._video_element_locator)
player = HTML5Player(self.marionette, video)
# Check that video is playing
player.wait_for_video_loaded()
self.assertTrue(player.is_video_playing())
# Pause playback
player.pause()
stopped_at = player.current_timestamp
self.assertFalse(player.is_video_playing())
# Resume playback
player.play()
resumed_at = player.current_timestamp
self.assertTrue(player.is_video_playing())
# Ensure that video resumes to play
# from the place where it was paused
delay = resumed_at - stopped_at
self.assertLessEqual(delay, self.acceptable_delay,
'video resumed to play not from place where it was paused')
def test_play_youtube_video(self):
""" Confirm YouTube video playback
https://moztrap.mozilla.org/manage/case/6073/
"""
browser = Browser(self.marionette)
browser.launch()
browser.go_to_url(self.video_URL)
browser.switch_to_content()
# Tap the video
self.wait_for_element_present(*self._video_container_locator)
self.marionette.find_element(*self._video_container_locator).tap()
self.marionette.switch_to_frame()
fullscreen_video = FullscreenVideo(self.marionette)
# Switch to video player
fullscreen_video.switch_to_video_frame()
# Check for playback
self.assertTrue(fullscreen_video.is_video_playing)
def test_browser_bookmark(self):
# https://github.com/mozilla/gaia-ui-tests/issues/452
browser = Browser(self.marionette)
browser.launch()
browser.go_to_url("http://mozqa.com/data/firefox/layout/mozilla.html")
browser.tap_bookmark_button()
bookmark = browser.tap_add_bookmark_to_home_screen_choice_button()
bookmark.switch_to_add_bookmark_frame()
bookmark.type_bookmark_title(self.bookmark_title)
bookmark.tap_add_bookmark_to_home_screen_dialog_button()
# Switch to Home Screen to look for bookmark
self.device.touch_home_button()
homescreen = Homescreen(self.marionette)
self._bookmark_added = homescreen.is_app_installed(self.bookmark_title)
self.assertTrue(
self._bookmark_added,
"The bookmark %s was not found to be installed on the home screen." % self.bookmark_title,
)
def test_browser_back_button(self):
# https://github.com/mozilla/gaia-ui-tests/issues/450
browser = Browser(self.marionette)
browser.launch()
browser.go_to_url('http://mozqa.com/data/firefox/layout/mozilla.html')
browser.switch_to_content()
self.verify_home_page()
self.marionette.tap(
self.marionette.find_element(*self._community_link_locator))
self.verify_community_page()
browser.switch_to_chrome()
browser.tap_back_button()
browser.switch_to_content()
self.verify_home_page()
browser.switch_to_chrome()
browser.tap_forward_button()
browser.switch_to_content()
self.verify_community_page()
def test_browser_back_button(self):
browser = Browser(self.marionette)
browser.launch()
browser.go_to_url(self.test_url)
browser.switch_to_content()
Wait(self.marionette).until(lambda m: m.title == 'Mozilla')
link = self.marionette.find_element(By.CSS_SELECTOR, '#community a')
# TODO: remove the explicit scroll once bug 833370 is fixed
self.marionette.execute_script('arguments[0].scrollIntoView(false);',
[link])
link.tap()
Wait(self.marionette).until(lambda m: m.title == 'Mozilla Community')
browser.switch_to_chrome()
browser.tap_back_button()
browser.switch_to_content()
Wait(self.marionette).until(lambda m: m.title == 'Mozilla')
browser.switch_to_chrome()
browser.tap_forward_button()
browser.switch_to_content()
Wait(self.marionette).until(lambda m: m.title == 'Mozilla Community')
def test_play_youtube_video(self):
""" Confirm YouTube video playback
https://moztrap.mozilla.org/manage/case/6073/
"""
browser = Browser(self.marionette)
browser.launch()
browser.go_to_url(self.video_URL)
browser.switch_to_content()
# Tap the video
self.wait_for_element_present(*self._video_container_locator)
self.marionette.find_element(*self._video_container_locator).tap()
self.marionette.switch_to_frame()
fullscreen_video = FullscreenVideo(self.marionette)
# Switch to video player
fullscreen_video.switch_to_video_frame()
# Check for playback
self.assertTrue(fullscreen_video.is_video_playing)
def test_browser_https_auth_login(self):
browser = Browser(self.marionette)
browser.launch()
browser.go_to_url('http://mozqa.com/data/mozqa.com/http_auth/')
browser.switch_to_content()
self.wait_for_element_present(*self._login_link_locator)
login_link = self.marionette.find_element(*self._login_link_locator)
login_link.tap()
browser.switch_to_chrome()
auth_region = AuthenticationDialog(self.marionette)
auth_region.authenticate('mozilla', 'mozilla')
self.wait_for_condition(lambda m: browser.url == self._success_redirect_url)
browser.switch_to_content()
self.wait_for_element_displayed(*self._success_message_locator)
success_message = self.marionette.find_element(*self._success_message_locator)
self.assertEquals('Basic Authentication is successful!', success_message.text)
