def test_that_clicking_on_featured_app_loads_details_page(self, mozwebqa):
home_page = Home(mozwebqa)
home_page.go_to_homepage()
details_page = home_page.click_on_first_app()
Assert.true(details_page.is_the_current_page)
def test_that_user_can_set_up_pre_approval_on_payment_settings_page(self, mozwebqa):
"""
Test for Litmus 58172.
https://litmus.mozilla.org/show_test.cgi?id=58172
"""
# We have to first log in to PayPal developer to access the PayPal sandbox
self._developer_page_login_to_paypal(mozwebqa)
# Login to consumer pages
home_page, user = self._login_to_consumer_pages(mozwebqa, 'add_preapproval')
# get to payment settings page
payment_settings_page = self._open_payment_settings_page(home_page)
try:
# set up non-pre-approval precondition
if payment_settings_page.is_remove_pre_approval_button_visible:
payment_settings_page.click_remove_pre_approval()
Assert.false(payment_settings_page.is_remove_pre_approval_button_visible)
# do test
payment_settings_page = self._set_up_pre_approval(payment_settings_page)
# verify
Assert.true(payment_settings_page.is_pre_approval_enabled)
Assert.true(payment_settings_page.is_success_message_visible)
finally:
# clean up
if payment_settings_page.is_remove_pre_approval_button_visible:
payment_settings_page.click_remove_pre_approval()
Assert.false(payment_settings_page.is_remove_pre_approval_button_visible)
def test_visitor_can_view_history(self, mozwebqa):
home_pg = HomePage(mozwebqa)
home_pg.go_to_home_page()
history_pg = home_pg.header_region.click_history()
Assert.true(history_pg.is_the_current_page)
Assert.greater(len(history_pg.history_list.strip()), 0)
def test_that_verifies_the_url_of_the_statistics_page(self, mozwebqa):
details_page = Details(mozwebqa, "Firebug")
statistics_page = details_page.click_view_statistics()
Assert.true(statistics_page.is_the_current_page)
Assert.contains("/statistics", statistics_page.get_url_current_page())
def test_submit_sad_feedback(self, mozwebqa):
timestamp = str(time.time())
desc = 'input-tests testing sad feedback ' + timestamp
url = 'http://sad.example.com/' + timestamp
# 1. go to the feedback form
feedback_pg = GenericFeedbackFormPage(mozwebqa)
feedback_pg.go_to_feedback_page()
# 2. click on sad
feedback_pg.click_sad_feedback()
# 3. fill out description and url
feedback_pg.set_description(desc)
feedback_pg.set_url(url)
feedback_pg.click_moreinfo_next()
# 4. fill in email address
feedback_pg.check_email_checkbox()
feedback_pg.set_email('*****@*****.**')
# 5. submit
thanks_pg = feedback_pg.submit(expect_success=True)
Assert.true(thanks_pg.is_the_current_page)
# 6. verify
dashboard_pg = DashboardPage(mozwebqa)
dashboard_pg.go_to_dashboard_page()
dashboard_pg.search_for(desc)
resp = dashboard_pg.messages[0]
Assert.equal(resp.type.strip(), 'Sad')
Assert.equal(resp.body.strip(), desc.strip())
Assert.equal(resp.locale.strip(), 'English (US)')
Assert.equal(resp.site.strip(), 'example.com')
def test_sorted_by_most_users_is_default(self, mozwebqa):
"""Test for Litmus 15346."""
home_page = Home(mozwebqa)
themes_page = home_page.header.site_navigation_menu("Themes").click()
url_current_page = themes_page.get_url_current_page()
Assert.true(url_current_page.endswith("/themes/"))
Assert.equal(themes_page.sorted_by, 'Most Users')
def test_browserid_link_present(self, mozwebqa):
home_page = Home(mozwebqa)
home_page.login()
profile_page = home_page.header.click_view_profile_menu_item()
edit_profile_page = profile_page.click_edit_my_profile_button()
account_tab = edit_profile_page.go_to_tab("account")
Assert.true(account_tab.is_browserid_link_present)
def test_that_checks_required_field_validations_on_basic_info_for_a_free_app(self, mozwebqa):
"""Ensure that all required fields generate warning messages and prevent form submission.
Litmus link: https://litmus.mozilla.org/show_test.cgi?id=50478
"""
dev_home = Home(mozwebqa)
dev_home.go_to_developers_homepage()
dev_home.login(user="******")
my_apps = dev_home.header.click_my_submissions()
# bring up the basic info form for the first free app
edit_listing = my_apps.first_free_app.click_edit()
# check App URL validation
basic_info_region = edit_listing.click_edit_basic_info()
basic_info_region.type_url_end('')
basic_info_region.click_save_changes()
Assert.true(basic_info_region.is_this_form_open)
Assert.contains('This field is required.', basic_info_region.url_end_error_message)
basic_info_region.click_cancel()
# check Summary validation
basic_info_region = edit_listing.click_edit_basic_info()
basic_info_region.type_description('')
basic_info_region.click_save_changes()
Assert.true(basic_info_region.is_this_form_open)
Assert.contains('This field is required.', basic_info_region.description_error_message)
basic_info_region.click_cancel()
def test_that_events_front_page_shows_upcoming_events(self, mozwebqa):
home_page = HomePage(mozwebqa)
home_page.go_to_page()
events_page = home_page.header.go_to_events_page()
Assert.true(events_page.upcoming_events_count > 0)
Assert.true(events_page.upcoming_events_is_visible)
def test_non_ascii_characters_are_allowed_in_profile_information(self, mozwebqa):
user = self.get_new_user()
home_page = Home(mozwebqa)
profile = home_page.create_new_user(user)
profile.set_full_name("New MozilliansUser")
profile.set_bio("Hello, I'm new here and trying stuff out. Oh, and by the way: I'm a robot, run in a cronjob, most likely")
skills = profile.click_next_button()
skills.add_skill(u'\u0394\u03D4\u03D5\u03D7\u03C7\u03C9\u03CA\u03E2')
skills.add_language(u'\u0394\u03D4\u03D5\u03D7\u03C7\u03C9\u03CA\u03E2')
location = skills.click_next_button()
location.select_country('gr')
location.set_state('Greece')
location.set_city('Athens')
location.check_privacy()
profile_page = location.click_create_profile_button()
Assert.true(profile_page.was_account_created_successfully)
Assert.true(profile_page.is_pending_approval_visible)
Assert.equal('New MozilliansUser', profile_page.name)
Assert.equal(user['email'], profile_page.email)
Assert.equal("Hello, I'm new here and trying stuff out. Oh, and by the way: I'm a robot, run in a cronjob, most likely", profile_page.biography)
Assert.equal(u'\u0394\u03D4\u03D5\u03D7\u03C7\u03C9\u03CA\u03E2', profile_page.skills)
Assert.equal(u'\u0394\u03D4\u03D5\u03D7\u03C7\u03C9\u03CA\u03E2', profile_page.languages)
Assert.equal('Athenes, Greece\nGreece', profile_page.location)
def test_submit_happy_feedback_with_unicode(self, mozwebqa):
"""Fill out happy feedback with unicode description"""
timestamp = unicode(time.time())
desc = u'input-tests testing happy feedback with unicode \u2603'
desc = desc + u' ' + timestamp
# 1. go to the feedback form
feedback_pg = GenericFeedbackFormPage(mozwebqa)
feedback_pg.go_to_feedback_page()
# 2. click on happy
feedback_pg.click_happy_feedback()
# 3. fill out description and url
feedback_pg.set_description(desc)
feedback_pg.click_moreinfo_next()
# 4. submit
thanks_pg = feedback_pg.submit(expect_success=True)
Assert.true(thanks_pg.is_the_current_page)
# 5. verify
dashboard_pg = DashboardPage(mozwebqa)
dashboard_pg.go_to_dashboard_page()
dashboard_pg.search_for(desc)
resp = dashboard_pg.messages[0]
Assert.equal(resp.type.strip(), 'Happy')
Assert.equal(resp.body.strip(), desc.strip())
def test_that_most_popular_link_is_default(self, mozwebqa):
"""Test for Litmus 15348"""
home_page = Home(mozwebqa)
themes_page = home_page.header.site_navigation_menu("Themes").click()
url_current_page = themes_page.get_url_current_page()
Assert.true(url_current_page.endswith("/themes/"))
Assert.equal(themes_page.selected_explore_filter, 'Most Popular')
def test_profile_creation(self, mozwebqa):
user = self.get_new_user()
home_page = Home(mozwebqa)
profile = home_page.create_new_user(user)
profile.set_full_name("New MozilliansUser")
profile.set_bio("Hello, I'm new here and trying stuff out. Oh, and by the way: I'm a robot, run in a cronjob, most likely")
skills = profile.click_next_button()
skills.add_skill('test')
skills.add_language('english')
location = skills.click_next_button()
location.select_country('us')
location.set_state('California')
location.set_city('Mountain View')
location.check_privacy()
profile_page = location.click_create_profile_button()
Assert.true(profile_page.was_account_created_successfully)
Assert.true(profile_page.is_pending_approval_visible)
Assert.equal('New MozilliansUser', profile_page.name)
Assert.equal(user['email'], profile_page.email)
Assert.equal("Hello, I'm new here and trying stuff out. Oh, and by the way: I'm a robot, run in a cronjob, most likely", profile_page.biography)
Assert.equal('test', profile_page.skills)
Assert.equal('english', profile_page.languages)
Assert.equal('Mountain View, California\nUnited States', profile_page.location)
def test_hide_email_checkbox_works(self, mozwebqa):
home_page = Home(mozwebqa)
home_page.login("browserID")
Assert.true(home_page.is_the_current_page)
Assert.true(home_page.header.is_user_logged_in)
view_profile_page = home_page.header.click_view_profile()
initial_state = view_profile_page.is_email_field_present
edit_profile_page = home_page.header.click_edit_profile()
edit_profile_page.change_hide_email_state()
edit_profile_page.click_update_account()
view_profile_page = home_page.header.click_view_profile()
final_state = view_profile_page.is_email_field_present
try:
Assert.not_equal(initial_state, final_state, 'The initial and final states are the same. The profile change failed.')
if final_state is True:
credentials = mozwebqa.credentials['default']
Assert.equal(credentials['email'], view_profile_page.email_value, 'Actual value is not equal with the expected one.')
except Exception as exception:
Assert.fail(exception.msg)
finally:
if initial_state != final_state:
edit_profile_page = home_page.header.click_edit_profile()
edit_profile_page.change_hide_email_state()
edit_profile_page.click_update_account()
view_profile_page = home_page.header.click_view_profile()
Assert.equal(view_profile_page.is_email_field_present, initial_state, 'Could not restore profile to initial state.')
def test_that_checks_editing_basic_info_for_a_free_app(self, mozwebqa):
"""Test the happy path for editing the basic information for a free submitted app.
Litmus link: https://litmus.mozilla.org/show_test.cgi?id=50478
"""
updated_app = MockApplication(
categories=[('Entertainment', False), ('Games', True), ('Music', True)],
)
dev_home = Home(mozwebqa)
dev_home.go_to_developers_homepage()
dev_home.login(user="******")
my_apps = dev_home.header.click_my_submissions()
edit_listing = my_apps.first_free_app.click_edit()
# bring up the basic info form for the first free app
basic_info_region = edit_listing.click_edit_basic_info()
# update the details of the app
basic_info_region.type_url_end(updated_app['url_end'])
basic_info_region.type_description(updated_app['description'])
for category in updated_app['categories']:
# check/uncheck the checkbox according to the app value
basic_info_region.select_categories(*category)
basic_info_region.click_save_changes()
# check that the listing has been updated
Assert.true(edit_listing.no_forms_are_open)
Assert.contains(updated_app['url_end'], edit_listing.url_end)
Assert.equal(edit_listing.description, updated_app['description'])
Assert.equal(edit_listing.categories.sort(), updated_app['categories'].sort())
def test_that_new_review_is_saved(self, mozwebqa):
"""
Test for Litmus 22921.
https://litmus.mozilla.org/show_test.cgi?id=22921
"""
# Step 1 - Login into AMO
home_page = Home(mozwebqa)
home_page.login("browserID")
Assert.true(home_page.is_the_current_page)
Assert.true(home_page.header.is_user_logged_in)
# Step 2 - Load any addon detail page
details_page = Details(mozwebqa, 'Adblock Plus')
# Step 3 - Click on "Write review" button
write_review_block = details_page.click_to_write_review()
# Step 4 - Write a review
body = 'Automatic addon review by Selenium tests %s' % datetime.now()
write_review_block.enter_review_with_text(body)
write_review_block.set_review_rating(1)
review_page = write_review_block.click_to_save_review()
# Step 5 - Assert review
review = review_page.reviews[0]
Assert.equal(review.rating, 1)
Assert.equal(review.author, mozwebqa.credentials['default']['name'])
date = datetime.now().strftime("%B %d, %Y")
# there are no leading zero-signs on day so we need to remove them too
date = date.replace(' 0', ' ')
Assert.equal(review.date, date)
Assert.equal(review.text, body)
def test_that_resources_page_display_makes(self, mozwebqa):
home_page = HomePage(mozwebqa)
home_page.go_to_page()
resources_page = home_page.header.click_teach_tab()
Assert.greater(resources_page.teach_make_count, 0)
Assert.true(resources_page.is_teach_makes_visible)
def test_that_one_star_rating_increments(self, mozwebqa):
"""
Test for Litmus 22916.
https://litmus.mozilla.org/show_test.cgi?id=22916
"""
# Step 1 - Login into AMO
home_page = Home(mozwebqa)
home_page.login("browserID")
Assert.true(home_page.header.is_user_logged_in)
# Step 2 - Go to add-ons listing page sorted by rating
extensions_home_page = home_page.click_to_explore('Top Rated')
# Step 3 - Pick an addon with no reviews
extensions_home_page.paginator.click_last_page()
addon = extensions_home_page.extensions[-1] # the last one is without rating
details_page = addon.click()
# Step 4 - Click on the "Write review" button
write_review_block = details_page.click_to_write_review()
# Step 5 - Add review with 1-star rating
body = 'Automatic addon review by Selenium tests'
write_review_block.enter_review_with_text(body)
write_review_block.set_review_rating(1)
view_reviews = write_review_block.click_to_save_review()
# Step 6 - Ensure rating increased by one
view_reviews.breadcrumbs[2].click()
details_page = Details(mozwebqa)
new_rating_counter = details_page.get_rating_counter(1)
Assert.equal(new_rating_counter, 1)
def test_that_checks_the_deletion_of_a_review(self, mozwebqa):
"""
https://moztrap.mozilla.org/manage/case/648/
"""
# Step 1 - Login into Marketplace
mock_review = MockReview()
home_page = Home(mozwebqa)
home_page.go_to_homepage()
home_page.login()
Assert.true(home_page.is_the_current_page)
# Step 2 - Search for the test app and go to its details page
search_page = home_page.header.search(self.test_app)
details_page = search_page.results[0].click_name()
Assert.true(details_page.is_the_current_page)
Assert.true(details_page.is_write_review_link_visible)
# Step 3 - Write a review
add_review_box = details_page.click_write_review()
reviews_page = add_review_box.write_a_review(mock_review['rating'], mock_review['body'])
# Step 4 - Check review
Assert.true(reviews_page.is_success_message_visible)
# Step 5 - Delete review
reviews = reviews_page.reviews[0]
reviews.delete()
Assert.true(reviews_page.is_success_message_visible)
Assert.equal(reviews_page.success_message, "Your review was successfully deleted!")
Assert.false(reviews.is_review_visible)
def test_search_by_library_name_returns_library(self, mozwebqa):
homepage_obj = HomePage(mozwebqa)
loginpage_obj = LoginPage(mozwebqa)
dashboard_obj = DashboardPage(mozwebqa)
librarypage_obj = LibraryEditorPage(mozwebqa)
searchpage_obj = SearchPage(mozwebqa)
homepage_obj.go_to_home_page()
homepage_obj.header.click_signin()
loginpage_obj.login()
#create a new library with the valid criteria (version not initial)
dashboard_obj.header.click_home_logo()
homepage_obj.click_create_lib_btn()
librarypage_obj.type_library_version('searchable')
librarypage_obj.click_save()
searchterm = librarypage_obj.library_name
librarypage_obj.header.click_home_logo()
homepage_obj.header.click_search()
searchpage_obj.search_until_package_exists(searchterm, searchpage_obj.library(searchterm))
Assert.true(searchpage_obj.library(searchterm).is_displayed, '%s not found before timeout' % searchterm)
searchpage_obj.delete_test_data()
def home_page_logged_in(mozwebqa):
from pages.login import LoginPage
login_pg = LoginPage(mozwebqa)
login_pg.go_to_login_page()
home_pg = login_pg.login()
Assert.true(home_pg.is_logged_in, "Could not determine if logged in")
return home_pg
def update_app_data(self, mock_app):
# update the default app data with the custom mock app information
data = {
'name': mock_app.name,
'summary': mock_app.summary,
'categories': [],
'support_email': mock_app.support_email,
'device_types': [],
'payment_type': mock_app.payment_type,
'premium_type': 'free',
'privacy_policy': mock_app.privacy_policy,
'description': mock_app.description,
'homepage': mock_app.homepage,
'support_url': mock_app.support_website
}
# device_types: a list of the device types at least one of: 'desktop', 'android-tablet', 'android-mobile', 'firefoxos'
data['device_types'] = [device[0] for device in mock_app['device_type'] if device[1]]
Assert.true(data['device_types'], 'insufficient data added device_types')
# categories: a list of the categories, at least two of the category ids provided from the category api
data['categories'] = [category['id'] for category in self._categories
if category['name'] in [mock_category[0] for mock_category in mock_app.categories]]
Assert.greater_equal(len(data['categories']), 2,
'Insufficient data added categories == %s\n Minimum 2 categories required' % data['categories'])
response = self._client.update(mock_app.id, data)
Assert.equal(response.status_code, 202, "Update app data failed.\n Status code %s" % response.status_code)
def test_breadcrumb_menu_in_persona_details_page(self, testsetup):
""" Test for Litmus 12046
https://litmus.mozilla.org/show_test.cgi?id=12046"""
# Step 1, 2: Access AMO Homepage, Click on Persona category link.
amo_home_page = AddonsHomePage(testsetup)
amo_personas_page = amo_home_page.click_personas()
Assert.true(amo_personas_page.is_the_current_page)
# Step 3: Click on any persona.
random_persona_index = random.randint(1, amo_personas_page.persona_count)
print "random_persona_index: %s" % str(random_persona_index)
amo_personas_detail_page = amo_personas_page.click_persona(random_persona_index)
print "url_current_page: %s" % str(amo_personas_detail_page.get_url_current_page())
Assert.true(amo_personas_detail_page.is_the_current_page)
# Verify breadcrumb menu format, i.e. Add-ons for Firefox > Personas > {Persona Name}.
persona_title = amo_personas_detail_page.personas_title
Assert.equal("Add-ons for Firefox", amo_personas_detail_page.get_breadcrumb_item_text(1))
Assert.equal("Personas", amo_personas_detail_page.get_breadcrumb_item_text(2))
Assert.equal(persona_title, amo_personas_detail_page.get_breadcrumb_item_text(3))
# Step 4: Click on the links present in the Breadcrumb menu.
# Verify that the Personas link loads the Personas home page.
amo_personas_detail_page.click_breadcrumb_item("Personas")
Assert.true(amo_personas_page.is_the_current_page)
amo_personas_page.return_to_previous_page()
Assert.true(amo_personas_detail_page.is_the_current_page)
# Verify that the Add-ons for Firefox link loads the AMO home page.
amo_personas_detail_page.click_breadcrumb_item("Add-ons for Firefox")
Assert.true(amo_home_page.is_the_current_page)
def test_sorting_by_downloads(self, mozwebqa):
""" Litmus 17342
https://litmus.mozilla.org/show_test.cgi?id=17342 """
AddonsHomePage(mozwebqa).header.search_for('firebug')
amo_search_page = AddonsSearchHomePage(mozwebqa).sort_by('downloads')
Assert.true('sort=weeklydownloads' in amo_search_page.get_url_current_page())
Assert.is_sorted_descending([i.downloads for i in amo_search_page.results()])
def test_that_reviews_are_displayed(self, mozwebqa):
"""Test for Litmus 9890."""
details_page = Details(mozwebqa, "Firebug")
Assert.equal(details_page.review_title, "Reviews")
Assert.true(details_page.has_reviews)
for review in details_page.review_details:
Assert.not_none(review)
def test_the_featured_personas_section(self, testsetup):
""" Test for Litmus 15392
https://litmus.mozilla.org/show_test.cgi?id=15392"""
amo_home_page = AddonsHomePage(testsetup)
amo_personas_page = amo_home_page.click_personas()
Assert.true(amo_personas_page.is_the_current_page)
Assert.equal(6, amo_personas_page.featured_personas_count)
def test_events_timeline_is_visible(self, mozwebqa):
home_page = Home(mozwebqa)
events_page = home_page.header.click_events_link()
events_page.click_timeline()
events_page.wait_for_page_to_load()
Assert.true(events_page.is_events_timeline_visible)
def test_advanced_options_are_visible(self, mozwebqa):
home_page = Home(mozwebqa)
events_page = home_page.header.click_events_link()
events_page.click_advanced_options()
Assert.true(events_page.is_advanced_search_form_visible)
Assert.true(events_page.is_events_icalendar_export_button_visible)
def test_sorting_by_updated_date(self, mozwebqa):
""" Litmus 17345
https://litmus.mozilla.org/show_test.cgi?id=17345 """
AddonsHomePage(mozwebqa).header.search_for('firebug')
amo_search_page = AddonsSearchHomePage(mozwebqa).sort_by('updated')
Assert.true('sort=updated' in amo_search_page.get_url_current_page())
Assert.is_sorted_descending([i.updated_date for i in amo_search_page.results()])
def test_cant_find_what_youre_looking_for_test(self, mozwebqa, search_term):
search_page_obj = PageProvider(mozwebqa).search_page()
search_page_obj.do_search_on_search_box(search_term)
expected_text = "Can't find what you're looking for?"
Assert.contains(expected_text, search_page_obj.ask_a_question_text)
Assert.true(search_page_obj.is_ask_a_question_present, "Ask question link not present")
def test_filtering_apps_by_device_type(self, mozwebqa, search_filter):
home_page = Home(mozwebqa)
home_page.go_to_homepage()
Assert.true(home_page.is_the_current_page)
search_page = home_page.header.search("")
result_count_before_filter = search_page.results_count
Assert.greater(result_count_before_filter, 0, "No results on the page")
search_page.filter_by(search_filter).click()
result_count_after_filter = search_page.results_count
Assert.greater(result_count_before_filter, result_count_after_filter)
Assert.contains(search_filter, search_page.applied_filters)
[
Assert.contains(search_filter, result.available_devices)
for result in search_page.results
]
def test_that_user_can_login_and_logout(self, mozwebqa):
from pages.login_page import MozTrapLoginPage
login_pg = MozTrapLoginPage(mozwebqa)
home_pg = MozTrapHomePage(mozwebqa)
home_pg.get_relative_path('/')
Assert.false(home_pg.header.is_user_logged_in)
login_pg.go_to_login_page()
login_pg.login()
user = home_pg.testsetup.credentials['default']
users_name = user['name']
Assert.true(home_pg.header.is_user_logged_in)
Assert.equal(home_pg.header.username_text, users_name)
home_pg.header.click_logout()
home_pg.get_relative_path('/')
Assert.false(home_pg.header.is_user_logged_in)
def test_add_review_after_sign_in_from_details_page(
self, mozwebqa, new_user):
# Go to Marketplace Home page
mock_review = MockReview()
home_page = Home(mozwebqa)
home_page.go_to_homepage()
Assert.true(home_page.is_the_current_page)
# Search for the test app and go to its details page
search_term = self._take_first_free_app_name(mozwebqa)
details_page = home_page.header.search_and_click_on_app(search_term)
Assert.true(details_page.is_the_current_page)
Assert.equal(details_page.review_button_text, "Sign in to review")
# Login
add_review_box = details_page.click_review_button()
details_page.login(new_user['email'], new_user['password'])
add_review_box.write_a_review(mock_review['rating'],
mock_review['body'])
Assert.equal(details_page.first_review_rating, mock_review['rating'])
Assert.equal(details_page.first_review_body, mock_review['body'])
def collect_links(self, url, name=True, **kwargs):
""" Collects links for given page URL.
If name is True, then links will be collected for whole page.
Use name argument to pass tag name of element.
Use kwargs to pass id of element or its class name.
Because 'class' is a reserved keyword in Python,
you need to pass class as: **{'class': 'container row'}.
"""
# support for relative URL
if not url.startswith('http'):
url = u'%s%s' % (self.base_url, url)
# get the page and verify status code is OK
r = requests.get(url, verify=False)
Assert.true(r.status_code == requests.codes.ok,
u'{0.url} returned: {0.status_code} {0.reason}'.format(r))
# parse page and collect links
parsed_html = BeautifulSoup(r.text)
if url.endswith("/") or url.endswith("/community") or url.endswith(
"/category/events"):
urls = (anchor['href'] for anchor in parsed_html.select(
'#content a[href*="mozilla.org"]'))
else:
urls = (anchor['href'] for anchor in parsed_html.find(
name, attrs=kwargs).find_all('a'))
# filter non HTTP/HTTPS urls
urls = self._filter_links(urls)
# prepend base_url to relative links
return map(
lambda u: u
if not u.startswith('/') else '%s%s' % (self.base_url, u), urls)
def remove_vm(self, provisioning_data, current_page, provider_api_clients,
random_name):
'''Powers off and removes the VM'''
vm_pg = current_page.header.site_navigation_menu(
'Infrastructure').sub_navigation_menu('Virtual Machines').click()
vm_pg.power_off(['%s%s' % (provisioning_data["vm_name"], random_name)])
Assert.true(vm_pg.flash.message.startswith("Stop initiated"))
vm_pg.wait_for_vm_state_change(
'%s%s' % (provisioning_data["vm_name"], random_name), 'off', 12)
Assert.equal(
vm_pg.quadicon_region.get_quadicon_by_title(
'%s%s' %
(provisioning_data["vm_name"], random_name)).current_state,
'off', "vm running")
provider = provider_api_clients.values()[0]
if ('%s%s' % (provisioning_data["vm_name"], random_name) + "/" +
'%s%s' % (provisioning_data["vm_name"],
random_name) + ".vmx") in provider.list_vm() or \
'%s%s' % (provisioning_data["vm_name"], random_name) \
in provider.list_vm():
provider.delete_vm('%s%s' %
(provisioning_data["vm_name"], random_name))
def test_profile_deletion_confirmation(self, mozwebqa, vouched_user):
home_page = Home(mozwebqa)
home_page.login(vouched_user['email'], vouched_user['password'])
edit_profile_page = home_page.header.click_edit_profile_menu_item()
confirm_profile_delete_page = edit_profile_page.click_delete_profile_button()
Assert.true(confirm_profile_delete_page.is_confirm_text_present)
Assert.true(confirm_profile_delete_page.is_cancel_button_present)
Assert.true(confirm_profile_delete_page.is_delete_button_present)
def test_accordion(self, mozwebqa, home_page_logged_in):
home_pg = home_page_logged_in
Assert.true(home_pg.is_logged_in, "Could not determine if logged in")
vm_pg = home_pg.header.site_navigation_menu(
"Services").sub_navigation_menu("Virtual Machines").click()
Assert.true(vm_pg.is_the_current_page)
Assert.true(
len(vm_pg.accordion.accordion_items) == 3,
"Should be 3 accordion items")
vm_pg.accordion.accordion_items[1].click()
name = vm_pg.accordion.accordion_items[1].name
Assert.true(name == "My VMs", "Name should be 'My VMs'")
vm_pg.accordion.accordion_items[2].click()
name = vm_pg.accordion.accordion_items[2].name
Assert.false(name == "My VMs", "Name should NOT be 'My VMs'")
def test_results_page_items(self, mozwebqa):
home_page = Home(mozwebqa)
home_page.go_to_homepage()
search_term = self._take_first_free_app_name(mozwebqa)
search_page = home_page.header.search(search_term)
search_page.click_expand_button()
# check the first 5 results
for i in range(min(len(search_page.results), 5)):
Assert.true(search_page.results[i].is_install_button_visible)
Assert.true(search_page.results[i].is_icon_visible)
Assert.true(search_page.results[i].is_rating_visible)
Assert.true(search_page.results[i].are_screenshots_visible)
def test_next_report_navigation(self, mozwebqa):
home_page = Home(mozwebqa)
home_page.go_to_homepage()
search_page = home_page.header.search(self.search_term)
app_details_page = search_page.results[0].click_name()
statistics_page = app_details_page.click_statistics()
Assert.true(statistics_page.is_prev_disabled)
for i in range(0, 10):
next_report = statistics_page.click_next_button()
Assert.true(statistics_page.is_prev_visible)
Assert.false(statistics_page.is_prev_disabled)
for i in range(0, 10):
next_report = statistics_page.click_prev_button()
Assert.true(statistics_page.is_prev_visible)
Assert.true(statistics_page.is_prev_disabled)
def test_that_user_can_make_a_contribution_without_logging_into_amo(self, mozwebqa):
"""Test that checks if the user is able to make a contribution without logging in to AMO."""
addon_page = Details(mozwebqa, self.addon_name)
Assert.false(addon_page.header.is_user_logged_in)
contribution_snippet = addon_page.click_contribute_button()
paypal_frame = contribution_snippet.click_make_contribution_button()
Assert.true(addon_page.is_paypal_login_dialog_visible)
payment_popup = paypal_frame.login_to_paypal(user="******")
Assert.true(payment_popup.is_user_logged_into_paypal)
payment_popup.click_pay()
Assert.true(payment_popup.is_payment_successful)
payment_popup.close_paypal_popup()
Assert.true(addon_page.is_the_current_page)
def test_that_header_has_expected_items(self, mozwebqa):
home_page = Home(mozwebqa)
home_page.go_to_homepage()
Assert.true(home_page.header.is_logo_visible)
Assert.true(home_page.header.is_search_visible)
Assert.true(home_page.header.is_sign_in_visible)
def test_edit_profile_fields(self, mozwebqa):
home_page = Home(mozwebqa)
home_page.login()
profile_page = home_page.header.click_profile()
user_edit_page = profile_page.click_edit_profile()
Assert.true(user_edit_page.is_the_current_page)
# save initial values to restore them after the test is finished
fields_no = len(user_edit_page.profile_fields)
initial_value = [None] * fields_no
random_name = "test%s" % random.choice(string.lowercase)
# enter new values
for i in range(0, fields_no):
initial_value[i] = deepcopy(user_edit_page.profile_fields[i].field_value)
user_edit_page.profile_fields[i].clear_field()
user_edit_page.profile_fields[i].type_value(random_name)
user_edit_page.click_save_profile()
Assert.true(profile_page.is_update_message_visible)
profile_page.click_edit_profile()
# using try finally to ensure that the initial values are restore even if the Asserts fail.
try:
for i in range(0, fields_no):
Assert.contains(random_name, user_edit_page.profile_fields[i].field_value)
except Exception as exception:
Assert.fail(exception)
finally:
# go back and restore initial values
for i in range(0, fields_no):
user_edit_page.profile_fields[i].clear_field()
user_edit_page.profile_fields[i].type_value(initial_value[i])
user_edit_page.click_save_profile()
def test_can_change_user_password(self, mozwebqa):
user = MockUser()
home_pg = HomePage(mozwebqa)
home_pg.go_to_home_page()
bid_login = home_pg.click_sign_in()
bid_login.sign_in_new_user(user['email'], user['password'])
# Open restmail inbox, find the email
inbox = RestmailInbox(user['email'])
email = inbox.find_by_index(0)
# Load the BrowserID link from the email in the browser
mozwebqa.selenium.get(email.verify_user_link)
from browserid.pages.webdriver.complete_registration import CompleteRegistration
CompleteRegistration(mozwebqa.selenium, mozwebqa.timeout)
mozwebqa.selenium.get(mozwebqa.server_base_url)
from browserid.pages.webdriver.account_manager import AccountManager
account_manager = AccountManager(mozwebqa.selenium, mozwebqa.timeout)
Assert.contains(user['email'], account_manager.emails)
account_manager.click_edit_password()
account_manager.old_password = user['password']
new_password = "******"
account_manager.new_password = new_password
account_manager.click_password_done()
account_manager.click_sign_out()
home_pg.go_to_home_page()
bid_login = home_pg.click_sign_in()
bid_login.sign_in(user['email'], new_password)
home_pg.wait_for_user_login()
Assert.true(home_pg.is_logged_in)
def test_that_checks_the_editing_of_a_review(self, mozwebqa):
self._reviews_setup(mozwebqa)
home_page = Home(mozwebqa)
home_page.go_to_homepage()
# Login into Marketplace
home_page.header.click_sign_in()
acct = self.get_user(mozwebqa)
home_page.login(acct)
Assert.true(home_page.is_the_current_page)
# Search for the test app and go to its details page
search_page = home_page.header.search(self.app_name)
details_page = search_page.results[0].click_name()
Assert.true(details_page.is_the_current_page)
details_page.wait_for_review_button_visible()
Assert.equal(details_page.review_button_text, "Edit your review")
# Write a review
edit_review = details_page.click_review_button(edit_review=True)
mock_review = MockReview()
details_page = edit_review.write_a_review(mock_review['rating'], mock_review['body'])
# Check notification
details_page.wait_notification_box_visible()
Assert.equal(details_page.notification_message, "Your review was successfully edited")
details_page.wait_notification_box_not_visible()
# Go to reviews page and verify
reviews = details_page.click_all_reviews_button()
Assert.equal(reviews.logged_in_users_review.text, mock_review['body'])
Assert.equal(reviews.logged_in_users_review.rating, mock_review['rating'])
# Clean up
self.mk_api.delete_app_review(self.review_id)
def test_that_new_review_is_saved(self, mozwebqa):
# Step 1 - Login into AMO
home_page = Home(mozwebqa)
home_page.login()
Assert.true(home_page.is_the_current_page)
Assert.true(home_page.header.is_user_logged_in)
# Step 2 - Load any addon detail page
details_page = Details(mozwebqa, 'Memchaser')
# Step 3 - Click on "Write review" button
write_review_block = details_page.click_to_write_review()
# Step 4 - Write a review
body = 'Automatic addon review by Selenium tests %s' % datetime.now()
write_review_block.enter_review_with_text(body)
write_review_block.set_review_rating(1)
review_page = write_review_block.click_to_save_review()
# Step 5 - Assert review
review = review_page.reviews[0]
Assert.equal(review.rating, 1)
Assert.equal(review.author, mozwebqa.credentials['default']['name'])
date = datetime.now().strftime("%B %d, %Y")
# there are no leading zero-signs on day so we need to remove them too
expected_date = date.replace(' 0', ' ')
Assert.equal(review.date, expected_date, 'Date of review does not match the expected value. '
'Expected: "%s" but found "%s"' % (expected_date, review.date))
Assert.equal(review.text, body, 'Review text does not match expected value. '
'Expected: "%s", but found "%s"' % (body, review.text))
review.delete()
details_page = Details(mozwebqa, 'Memchaser')
review_page = details_page.click_all_reviews_link()
for review in review_page.reviews:
Assert.false(body in review.text)
def test_that_deletes_app(self, mozwebqa):
dev_home = Home(mozwebqa)
dev_home.go_to_developers_homepage()
dev_home.login(user="******")
my_apps = dev_home.header.click_my_submissions()
first_free_app = my_apps.first_free_app
app_name = first_free_app.name
self._delete_app(mozwebqa, app_name)
Assert.true(my_apps.is_notification_visible)
Assert.true(my_apps.is_notification_successful, my_apps.notification_message)
Assert.equal("App deleted.", my_apps.notification_message)
for i in range(1, my_apps.paginator.total_page_number + 1):
for app in my_apps.submitted_apps:
Assert.not_equal(app.name, app_name)
if my_apps.paginator.is_paginator_present:
if not my_apps.paginator.is_first_page_disabled:
my_apps.paginator.click_next_page()
def test_that_checks_required_field_validations_on_basic_info_for_a_free_app(
self, mozwebqa, login, free_app):
"""Ensure that all required fields generate warning messages and prevent form submission."""
edit_listing = self._go_to_edit_listing_page(mozwebqa, free_app)
# check App URL validation
basic_info_region = edit_listing.click_edit_basic_info()
basic_info_region.type_url_end('')
basic_info_region.click_save_changes()
Assert.true(basic_info_region.is_this_form_open)
Assert.contains('This field is required.',
basic_info_region.url_end_error_message)
basic_info_region.click_cancel()
# check Summary validation
basic_info_region = edit_listing.click_edit_basic_info()
basic_info_region.type_description('')
basic_info_region.click_save_changes()
Assert.true(basic_info_region.is_this_form_open)
Assert.contains('This field is required.',
basic_info_region.description_error_message)
basic_info_region.click_cancel()
def test_user_can_create_and_delete_report(self, mozwebqa):
test_link = 'http://test.com'
random_text = "test%s" % random.choice(string.lowercase)
home_page = Home(mozwebqa)
home_page.login()
dashboard = home_page.header.click_dashboard()
new_report = dashboard.click_add_new_report()
new_report.select_activity('3')
new_report.select_campaign('1')
new_report.select_contribution_area('Coding')
new_report.select_event_place()
new_report.type_url_for_activity(test_link)
new_report.type_url_description(random_text)
new_report.type_activity_description(random_text)
view_report = new_report.click_save_report_button()
Assert.true(view_report.is_success_message_visible)
Assert.contains('Report successfully created.', view_report.success_message_text)
edit_report = view_report.click_edit_report()
view_report = edit_report.delete_report()
Assert.true(view_report.is_success_message_visible)
Assert.contains('Report successfully deleted.', view_report.success_message_text)
def test_sign_up_with_valid_email(self, mozwebqa):
valid_email = '*****@*****.**'
country = 'us'
name = 'mozilla'
success_url_slug = 'thankyou'
contribute_page = Contribute(mozwebqa)
contribute_page.go_to_page()
signup_page = contribute_page.click_signup()
signup_page.click_testing_area()
signup_page.select_option(
'testing-firefox',
signup_page._sign_up_form_select_testing_area_locator)
signup_page.input_name(name)
signup_page.input_email(valid_email)
signup_page.select_option(
country, signup_page._sign_up_form_country_select_locator)
signup_page.select_html_format()
signup_page.check_privacy_checkbox()
signup_page.submit_form()
Assert.true(
success_url_slug in signup_page.url_current_page,
'Expected current URL slug to be %s, but was not found in %s.' %
(success_url_slug, signup_page.url_current_page))
def test_that_reports_abuse_as_anonymous_user(self, mozwebqa):
home_page = Home(mozwebqa)
home_page.go_to_homepage()
Assert.true(home_page.is_the_current_page)
search_term = self._take_first_free_app_name(mozwebqa)
details_page = home_page.header.search_and_click_on_app(search_term)
Assert.true(details_page.is_the_current_page)
Assert.true(details_page.is_report_abuse_button_visible)
report_abuse_box = details_page.click_report_abuse_button()
Assert.true(report_abuse_box.is_visible)
report_abuse_box.insert_text(
'This is an automatically generated report.')
Assert.true(report_abuse_box.is_report_button_enabled)
report_abuse_box.click_report_button()
details_page.wait_for_notification('Report submitted. Thanks!')
def test_that_filter_by_region_works(self, mozwebqa):
home_page = Home(mozwebqa)
home_page.login()
profile_page = home_page.open_user_profile(u'Mozillians.User')
region = profile_page.region
country = profile_page.country
search_results_page = profile_page.click_region_name(region=region, country=country)
expected_results_title = u'Mozillians in %s, %s' % (region, country)
actual_results_title = search_results_page.title
Assert.true(search_results_page.is_the_current_page)
Assert.equal(
expected_results_title, actual_results_title,
u'''Search results title is incorrect.
Expected: %s, but got: %s''' % (expected_results_title, actual_results_title))
random_profile = search_results_page.get_random_profile()
random_profile_region = random_profile.region
Assert.equal(
region, random_profile_region,
u'Expected region: %s, but got: %s' % (region, random_profile_region))
def test_that_user_can_clone_version(self, mozwebqa_logged_in):
manage_versions_pg = MozTrapManageVersionsPage(mozwebqa_logged_in)
version = self.create_version(mozwebqa_logged_in)
manage_versions_pg.filter_versions_by_name(name=version['name'])
cloned_version = manage_versions_pg.clone_version(
name=version['name'], product_name=version['product']['name'])
Assert.true(
manage_versions_pg.is_element_present(
*cloned_version['manage_locator']))
manage_versions_pg.delete_version(
name=cloned_version['name'],
product_name=cloned_version['product_name'])
Assert.false(
manage_versions_pg.is_element_present(
*cloned_version['manage_locator']))
self.delete_version(mozwebqa_logged_in, version, delete_product=True)
class TestRunTestsPage(BaseTest):
@pytest.mark.moztrap([205, 208])
def test_that_user_can_pass_test(self, api, mozwebqa, login, product,
element):
case = self.create_and_run_test(api, mozwebqa, product, element)[0]
run_tests_pg = MozTrapRunTestsPage(mozwebqa)
result = run_tests_pg.get_test_result(case['name'])
Assert.false(result.is_test_passed)
result.pass_test()
result = run_tests_pg.get_test_result(case['name'])
Assert.true(result.is_test_passed)
def test_that_user_can_create_and_delete_group(self, mozwebqa, vouched_user):
current_time = time.strftime("%x" + "-" + "%X")
group_name = ('qa_test' + ' ' + current_time)
home_page = Home(mozwebqa)
home_page.login(vouched_user['email'], vouched_user['password'])
edit_page = home_page.header.click_edit_profile_menu_item()
groups = edit_page.click_find_group_link()
create_group = groups.click_create_group_main_button()
create_group.create_group_name(group_name)
create_group.click_create_group_submit()
search_listings = create_group.header.search_for(group_name)
Assert.true(search_listings.is_element_present(By.LINK_TEXT, group_name))
group_info = search_listings.open_group(group_name)
groups_page = group_info.delete_group()
groups_page.wait_for_alert_message()
home_page.header.click_edit_profile_menu_item()
Assert.false(search_listings.is_element_present(By.LINK_TEXT, group_name))
def test_get_started_3_steps(self, mozwebqa):
start_page = StartPage(mozwebqa)
home_page = start_page.login()
Assert.true(home_page.is_the_current_url)
Assert.greater(home_page.category_count, 0,
'There are no categories in the list')
Assert.not_none(home_page.categories[0].name)
Assert.true(home_page.is_step_button_selected('first'))
# select the first category in the list
home_page.categories[0].select_category('second')
Assert.true(home_page.is_step_button_selected('second'))
Assert.not_none(home_page.categories[0].name)
# select the first banner in list
home_page.categories[0].select_category('third')
Assert.true(home_page.is_step_button_selected('third'))
def test_status_section(self, mozwebqa):
dnt_page = DoNotTrack(mozwebqa)
dnt_page.go_to_page()
Assert.true(dnt_page.is_status_wrapper_visible)
Assert.true(dnt_page.is_status_text_visible)
Assert.true(dnt_page.is_enable_dnt_image_visible)
Assert.true(dnt_page.is_enable_dnt_text_visible)
bad_links = []
for link in dnt_page.tracking_protection_links_list:
url = dnt_page.link_destination(link.get('locator'))
if not url.endswith(link.get('url_suffix')):
bad_links.append('%s does not end with %s' %
(url, link.get('url_suffix')))
Assert.equal(
0, len(bad_links),
'%s bad links found: ' % len(bad_links) + ', '.join(bad_links))
def test_remove_tag(self, infra_providers_pg):
"""Add a tag to a template
"""
# go to just provider vms, had issue with duplicate (archived) vms otherwise
prov_pg = infra_providers_pg.quadicon_region.click_random_quadicon()
infra_vms_pg = prov_pg.all_vms()
title = infra_vms_pg.quadicon_region.mark_random_quadicon_checkbox()
edit_tags_pg = infra_vms_pg.click_on_edit_tags()
tag_cat, tag_value = edit_tags_pg.add_random_tag()
Assert.true(edit_tags_pg.is_tag_displayed(tag_cat, tag_value))
edit_tags_pg.save_tag_edits()
infra_vms_pg.quadicon_region.mark_icon_checkbox([title])
edit_tags_pg = infra_vms_pg.click_on_edit_tags()
edit_tags_pg.delete_tag(tag_cat)
edit_tags_pg.save_tag_edits()
infra_vms_pg.quadicon_region.mark_icon_checkbox([title])
edit_tags_pg = infra_vms_pg.click_on_edit_tags()
Assert.false(edit_tags_pg.is_tag_displayed(tag_cat, tag_value))
def test_user_can_create_banner(self, mozwebqa):
start_page = StartPage(mozwebqa)
home_page = start_page.login()
create_banner_page = home_page.click_create_banner()
create_banner_page.choose_category()
create_banner_page.choose_banner()
create_banner_page.select_language('English (US)')
create_banner_page.select_size()
create_banner_page.select_color()
create_banner_page.click_save()
Assert.true(create_banner_page.is_embeded_code_generated)
# Get the id of the new banner from the page url
new_banner_id = create_banner_page.get_url_current_page.split('/')[-2]
create_banner_page.go_to_dashboard_page()
# Get the id of the last created banner in the list
last_banner_id = home_page.banners[len(home_page.banners) -
1].banner_link.split('/')[-2]
#Check that the new banner is the last on the list of banners
Assert.equal(new_banner_id, last_banner_id)
def test_start_exploring_link_in_the_promo_box(self, mozwebqa):
home_page = Home(mozwebqa)
themes_page = home_page.header.site_navigation_menu("Themes").click()
Assert.true(themes_page.is_the_current_page)
Assert.true(themes_page.is_featured_addons_present)
browse_themes_page = themes_page.click_start_exploring()
Assert.true(browse_themes_page.is_the_current_page)
Assert.equal("up-and-coming", browse_themes_page.sort_key)
Assert.equal("Up & Coming", browse_themes_page.sort_by)
def test_that_clicking_the_amo_logo_loads_home_page(self, mozwebqa):
home_page = Home(mozwebqa)
Assert.true(home_page.is_amo_logo_visible)
home_page = home_page.click_amo_logo()
Assert.true(home_page.is_the_current_page)
Assert.true(home_page.is_amo_logo_visible)
Assert.equal(home_page.get_url_current_page(),
'%s/en-US/firefox/' % home_page.base_url)
