def test_that_deleting_single_version_of_case_does_not_delete_all_versions(
self, api, mozwebqa, login, product):
# prerequisites
test_case = self.create_case(mozwebqa, product=product, api=api)
first_version = product['version']
second_version = self.create_version(mozwebqa, product=product)
product_versions = [
u'%s %s' % (product['name'], version['name'])
for version in (first_version, second_version)
]
manage_cases_pg = MozTrapManageCasesPage(mozwebqa)
manage_cases_pg.go_to_manage_cases_page()
filter_item = manage_cases_pg.filter_form.filter_by(
lookup='product', value=product['name'])
test_cases = manage_cases_pg.test_cases
# remember case version and delete case
deleted_version = test_cases[0].product_version
product_versions.remove(deleted_version)
test_cases[0].delete()
filter_item.remove_filter()
manage_cases_pg.filter_form.filter_by(lookup='name',
value=test_case['name'])
test_cases = manage_cases_pg.test_cases
# check that there is only one test case left and ensure its version equals to second version
Assert.equal(len(test_cases), 1, u'there should be only one case')
Assert.equal(test_cases[0].name, test_case['name'],
u'that\'s wrong test case')
Assert.equal(test_cases[0].product_version, product_versions[0],
u'that\'s wrong product version')
def test_that_pinning_filters_on_product_and_version_and_suite_set_defaults_in_new_case(self, mozwebqa_logged_in):
product = self.create_product(mozwebqa_logged_in)
version = product['version']
product_version_name = u'%s %s' % (product['name'], version['name'])
suite = self.create_suite(mozwebqa_logged_in, product=product)
from pages.manage_cases_page import MozTrapManageCasesPage
manage_cases_pg = MozTrapManageCasesPage(mozwebqa_logged_in)
manage_cases_pg.go_to_manage_cases_page()
filters = []
filters.append(manage_cases_pg.filter_form.filter_by(lookup='product', value=product['name']))
filters.append(manage_cases_pg.filter_form.filter_by(lookup='productversion', value=product_version_name))
filters.append(manage_cases_pg.filter_form.filter_by(lookup='suite', value=suite['name']))
for item in filters:
item.pin_filter()
Assert.equal(item.get_filter_color(), PINNED_FILTER_COLOR)
#go to create case page
create_case_pg = manage_cases_pg.click_create_case_button()
Assert.equal(create_case_pg.product_value, product['name'])
Assert.equal(create_case_pg.product_version_value, version['name'])
Assert.equal(create_case_pg.suite_value, suite['name'])
create_case_pg.go_back()
#go to create bulk cases page
create_bulk_cases_pg = manage_cases_pg.click_create_bulk_cases_button()
Assert.equal(create_bulk_cases_pg.product_value, product['name'])
Assert.equal(create_bulk_cases_pg.product_version_value, version['name'])
Assert.equal(create_bulk_cases_pg.suite_value, suite['name'])
def test_that_manage_cases_list_shows_all_case_versions_individually(
self, mozwebqa_logged_in, product):
#prerequisites
test_case = self.create_case(mozwebqa_logged_in,
product=product,
use_API=True)
first_version = product['version']
second_version = self.create_version(mozwebqa_logged_in,
product=product)
product_versions = [
u'%s %s' % (product['name'], version['name'])
for version in (first_version, second_version)
]
manage_cases_pg = MozTrapManageCasesPage(mozwebqa_logged_in)
manage_cases_pg.go_to_manage_cases_page()
manage_cases_pg.filter_form.filter_by(lookup='name',
value=test_case['name'])
filtered_cases = manage_cases_pg.test_cases
for case in filtered_cases:
Assert.equal(case.name, test_case['name'],
u'that\'s wrong case we\'ve got here')
#check that both product versions are displayed
Assert.equal(
sorted(product_versions),
sorted([case.product_version for case in filtered_cases]),
u'expected product versions of test cases don\'t match actual ones'
)
def test_that_pinning_filters_on_product_and_version_and_suite_set_defaults_in_new_case(self, api, mozwebqa, login, product):
version = product['version']
product_version_name = u'%s %s' % (product['name'], version['name'])
suite = self.create_suite(mozwebqa, product=product, api=api)
manage_cases_pg = MozTrapManageCasesPage(mozwebqa)
manage_cases_pg.go_to_manage_cases_page()
filters = []
filters.append(manage_cases_pg.filter_form.filter_by(lookup='product', value=product['name']))
filters.append(manage_cases_pg.filter_form.filter_by(lookup='productversion', value=product_version_name))
filters.append(manage_cases_pg.filter_form.filter_by(lookup='suite', value=suite['name']))
for item in filters:
item.pin_filter()
self.check_pinned_filter(item, is_pinned=True)
# go to create case page
create_case_pg = manage_cases_pg.click_create_case_button()
assert product['name'] == create_case_pg.product_value
assert version['name'] == create_case_pg.product_version_value
assert suite['name'] == create_case_pg.suite_value
create_case_pg.go_back()
# go to create bulk cases page
create_bulk_cases_pg = manage_cases_pg.click_create_bulk_cases_button()
assert product['name'] == create_bulk_cases_pg.product_value
assert version['name'] == create_bulk_cases_pg.product_version_value
assert suite['name'] == create_bulk_cases_pg.suite_value
def test_that_manage_cases_list_shows_all_case_versions_individually(
self, api, base_url, selenium, login, product):
# prerequisites
test_case = self.create_case(base_url,
selenium,
product=product,
api=api)
first_version = product['version']
second_version = self.create_version(base_url,
selenium,
product=product)
product_versions = [
u'%s %s' % (product['name'], version['name'])
for version in (first_version, second_version)
]
manage_cases_pg = MozTrapManageCasesPage(base_url, selenium)
manage_cases_pg.go_to_manage_cases_page()
manage_cases_pg.filter_form.filter_by(lookup='name',
value=test_case['name'])
filtered_cases = manage_cases_pg.test_cases
for case in filtered_cases:
assert test_case['name'] == case.name
# check that both product versions are displayed
assert sorted(product_versions) == sorted(
[case.product_version for case in filtered_cases])
def test_that_deleting_single_version_of_case_does_not_delete_all_versions(self, api, mozwebqa, login, product):
# prerequisites
test_case = self.create_case(mozwebqa, product=product, api=api)
first_version = product['version']
second_version = self.create_version(mozwebqa, product=product)
product_versions = [u'%s %s' % (product['name'], version['name'])
for version in (first_version, second_version)]
manage_cases_pg = MozTrapManageCasesPage(mozwebqa)
manage_cases_pg.go_to_manage_cases_page()
filter_item = manage_cases_pg.filter_form.filter_by(lookup='product', value=product['name'])
test_cases = manage_cases_pg.test_cases
# remember case version and delete case
deleted_version = test_cases[0].product_version
product_versions.remove(deleted_version)
test_cases[0].delete()
filter_item.remove_filter()
manage_cases_pg.filter_form.filter_by(lookup='name', value=test_case['name'])
test_cases = manage_cases_pg.test_cases
# check that there is only one test case left and ensure its version equals to second version
Assert.equal(len(test_cases), 1, u'there should be only one case')
Assert.equal(test_cases[0].name, test_case['name'], u'that\'s wrong test case')
Assert.equal(test_cases[0].product_version, product_versions[0], u'that\'s wrong product version')
def test_that_deleting_single_version_of_case_does_not_delete_all_versions(self, mozwebqa_logged_in, product):
"""test for https://www.pivotaltracker.com/projects/280483#!/stories/40857085"""
#prerequisites
first_version = product['version']
test_case = self.create_case(mozwebqa_logged_in, product=product, use_API=True, version=first_version)
second_version = self.create_version(mozwebqa_logged_in, product=product)
product_versions = [u'%s %s' % (product['name'], version['name']) for version in (first_version, second_version)]
manage_cases_pg = MozTrapManageCasesPage(mozwebqa_logged_in)
manage_cases_pg.go_to_manage_cases_page()
filter_item = manage_cases_pg.filter_form.filter_by(lookup='product', value=product['name'])
test_cases = manage_cases_pg.test_cases
#remember case version and delete case
deleted_version = test_cases[0].product_version
product_versions.remove(deleted_version)
test_cases[0].delete()
filter_item.remove_filter()
manage_cases_pg.filter_form.filter_by(lookup='name', value=test_case['name'])
test_cases = manage_cases_pg.test_cases
#check that there is only one test case left and ensure its version equals to second version
Assert.equal(len(test_cases), 1, u'there should be only one case')
Assert.equal(test_cases[0].name, test_case['name'], u'that\'s wrong test case')
Assert.equal(test_cases[0].product_version, product_versions[0], u'that\'s wrong product version')
def test_creating_a_tag_with_a_product_value_and_cases(self, api, mozwebqa, login, product):
# create some cases for product
cases = self.create_bulk_cases(mozwebqa, product, api=api)
manage_tags_pg = MozTrapManageTagsPage(mozwebqa)
manage_tags_pg.go_to_manage_tags_page()
create_tag_pg = manage_tags_pg.click_create_tag_button()
tag = MockTag(product=product['name'])
create_tag_pg.create_tag(tag, save_tag=False)
expected_case_names = [case.name for case in cases]
actual_case_names = [case.name for case in create_tag_pg.available_caseversions]
Assert.equal(sorted(expected_case_names), sorted(actual_case_names),
'list of expected caseversions differs from actually displayed')
create_tag_pg.include_caseversions_to_tag(expected_case_names)
manage_cases_page = MozTrapManageCasesPage(mozwebqa)
manage_cases_page.go_to_manage_cases_page()
manage_cases_page.filter_form.filter_by(lookup='tag', value=tag['name'])
displayed_case_names = [case.name for case in manage_cases_page.test_cases]
Assert.equal(sorted(expected_case_names), sorted(displayed_case_names),
'list of test cases attached to a tag differs from expected')
def test_that_pinning_filter_persists_for_session(self, api, mozwebqa, existing_user, login, product, element):
# create suite, cases and test run
product_version_name = u'%s %s' % (product['name'], product['version']['name'])
case, suite, run = self.create_and_run_test(api, mozwebqa, product, element)
# go to manage cases page
manage_cases_pg = MozTrapManageCasesPage(mozwebqa)
manage_cases_pg.go_to_manage_cases_page()
# filter on product
filter_item = manage_cases_pg.filter_form.filter_by(lookup='product', value=product['name'])
self.check_pinned_filter(filter_item, is_pinned=False)
# see only cases for specified product
displayed_cases = manage_cases_pg.test_cases
assert 1 == len(displayed_cases)
assert case.name.lower() == displayed_cases[0].name.lower()
# pin product filter
filter_item.pin_filter()
self.check_pinned_filter(filter_item, is_pinned=True)
# go to manage suites page
manage_suites_pg = MozTrapManageSuitesPage(mozwebqa)
manage_suites_pg.go_to_manage_suites_page()
# see only suites for specified product
displayed_suites = manage_suites_pg.test_suites
assert 1 == len(displayed_suites)
assert suite.name.lower() == displayed_suites[0].name.lower()
# go to results page
view_results_pg = MozTrapViewRunResultsPage(mozwebqa)
view_results_pg.go_to_view_run_results_page()
# see only results for specified product
# because we are going to check the same thing several times
# let's define a function and call it each time we need this check
def check_test_run_results(results):
assert 1 == len(results)
assert run['name'].lower() == results[0].name.lower()
assert product_version_name == results[0].product_version
check_test_run_results(view_results_pg.test_run_results)
# refresh page and see that filter persists
view_results_pg.refresh()
check_test_run_results(view_results_pg.test_run_results)
# log out and back in and see that filter persists
view_results_pg.header.click_logout()
view_results_pg.header.login(existing_user['email'], existing_user['password'])
check_test_run_results(view_results_pg.test_run_results)
# check that filter is still pinned
filters = view_results_pg.filter_form.filter_items
assert 1 == len(filters)
self.check_pinned_filter(filters[0], is_pinned=True)
def delete_case(self, mozwebqa, case, delete_product=False):
manage_cases_pg = MozTrapManageCasesPage(mozwebqa)
manage_cases_pg.go_to_manage_cases_page()
manage_cases_pg.filter_form.filter_by(lookup='name', value=case['name'])
manage_cases_pg.delete_case(name=case['name'])
if delete_product:
self.delete_product(mozwebqa, product=case['product'])
def test_that_user_can_create_and_delete_case(self, mozwebqa_logged_in, product):
manage_cases_pg = MozTrapManageCasesPage(mozwebqa_logged_in)
case = self.create_case(mozwebqa_logged_in, product, use_API=False)
manage_cases_pg.filter_form.filter_by(lookup='name', value=case['name'])
Assert.true(manage_cases_pg.is_element_present(*case['locator']))
manage_cases_pg.delete_case(name=case['name'])
Assert.false(manage_cases_pg.is_element_present(*case['locator']))
def test_that_user_can_create_and_delete_case(self, mozwebqa, login, product):
manage_cases_pg = MozTrapManageCasesPage(mozwebqa)
case = self.create_case(mozwebqa, product)
manage_cases_pg.filter_form.filter_by(lookup='name', value=case['name'])
assert manage_cases_pg.is_element_present(*case['locator'])
manage_cases_pg.delete_case(name=case['name'])
assert not manage_cases_pg.is_element_present(*case['locator'])
def test_that_user_can_create_and_delete_case(self, base_url, selenium,
login, product):
manage_cases_pg = MozTrapManageCasesPage(base_url, selenium)
case = self.create_case(base_url, selenium, product)
manage_cases_pg.filter_form.filter_by(lookup='name',
value=case['name'])
assert manage_cases_pg.is_element_present(*case['locator'])
manage_cases_pg.delete_case(name=case['name'])
assert not manage_cases_pg.is_element_present(*case['locator'])
def test_that_user_can_create_and_delete_case(self, mozwebqa_logged_in,
product):
manage_cases_pg = MozTrapManageCasesPage(mozwebqa_logged_in)
case = self.create_case(mozwebqa_logged_in, product, use_API=False)
manage_cases_pg.filter_form.filter_by(lookup='name',
value=case['name'])
Assert.true(manage_cases_pg.is_element_present(*case['locator']))
manage_cases_pg.delete_case(name=case['name'])
Assert.false(manage_cases_pg.is_element_present(*case['locator']))
def view_cases(self, name='Test Suite'):
_view_cases_locator = (self._view_cases_locator[0],
self._view_cases_locator[1] % {
'suite_name': name
})
self.selenium.find_element(*_view_cases_locator).click()
from pages.manage_cases_page import MozTrapManageCasesPage
return MozTrapManageCasesPage(self.testsetup)
def test_that_manage_cases_list_shows_all_case_versions_individually(self, api, mozwebqa, login, product):
# prerequisites
test_case = self.create_case(mozwebqa, product=product, api=api)
first_version = product['version']
second_version = self.create_version(mozwebqa, product=product)
product_versions = [u'%s %s' % (product['name'], version['name'])
for version in (first_version, second_version)]
manage_cases_pg = MozTrapManageCasesPage(mozwebqa)
manage_cases_pg.go_to_manage_cases_page()
manage_cases_pg.filter_form.filter_by(lookup='name', value=test_case['name'])
filtered_cases = manage_cases_pg.test_cases
for case in filtered_cases:
assert test_case['name'] == case.name
# check that both product versions are displayed
assert sorted(product_versions) == sorted([case.product_version for case in filtered_cases])
def test_that_manage_cases_list_shows_all_case_versions_individually(self, api, mozwebqa, login, product):
# prerequisites
test_case = self.create_case(mozwebqa, product=product, api=api)
first_version = product['version']
second_version = self.create_version(mozwebqa, product=product)
product_versions = [u'%s %s' % (product['name'], version['name'])
for version in (first_version, second_version)]
manage_cases_pg = MozTrapManageCasesPage(mozwebqa)
manage_cases_pg.go_to_manage_cases_page()
manage_cases_pg.filter_form.filter_by(lookup='name', value=test_case['name'])
filtered_cases = manage_cases_pg.test_cases
for case in filtered_cases:
Assert.equal(case.name, test_case['name'], u'that\'s wrong case we\'ve got here')
# check that both product versions are displayed
Assert.equal(
sorted(product_versions),
sorted([case.product_version for case in filtered_cases]),
u'expected product versions of test cases don\'t match actual ones')
def delete_case(self, base_url, selenium, case):
manage_cases_pg = MozTrapManageCasesPage(base_url, selenium)
manage_cases_pg.go_to_manage_cases_page()
manage_cases_pg.filter_form.filter_by(lookup='name',
value=case['name'])
manage_cases_pg.delete_case(name=case['name'])
def delete_case(self, mozwebqa, case):
manage_cases_pg = MozTrapManageCasesPage(mozwebqa)
manage_cases_pg.go_to_manage_cases_page()
manage_cases_pg.filter_form.filter_by(lookup='name',
value=case['name'])
manage_cases_pg.delete_case(name=case['name'])
def test_that_manage_cases_list_shows_all_case_versions_individually(self, mozwebqa_logged_in, product):
"""https://www.pivotaltracker.com/projects/280483#!/stories/40857159"""
#prerequisites
first_version = product['version']
test_case = self.create_case(mozwebqa_logged_in, product=product, use_API=True, version=first_version)
second_version = self.create_version(mozwebqa_logged_in, product=product)
product_versions = [u'%s %s' % (product['name'], version['name']) for version in (first_version, second_version)]
manage_cases_pg = MozTrapManageCasesPage(mozwebqa_logged_in)
manage_cases_pg.go_to_manage_cases_page()
manage_cases_pg.filter_form.filter_by(lookup='name', value=test_case['name'])
filtered_cases = manage_cases_pg.test_cases
for case in filtered_cases:
Assert.equal(case.name, test_case['name'], u'that\'s wrong case we\'ve got here')
#check that both product versions are displayed
Assert.equal(
sorted(product_versions),
sorted([case.product_version for case in filtered_cases]),
u'expected product versions of test cases don\'t match actual ones')
def test_that_deleting_single_version_of_case_does_not_delete_all_versions(
self, mozwebqa_logged_in, product):
"""test for https://www.pivotaltracker.com/projects/280483#!/stories/40857085"""
#prerequisites
first_version = product['version']
test_case = self.create_case(mozwebqa_logged_in,
product=product,
use_API=True,
version=first_version)
second_version = self.create_version(mozwebqa_logged_in,
product=product)
product_versions = [
u'%s %s' % (product['name'], version['name'])
for version in (first_version, second_version)
]
manage_cases_pg = MozTrapManageCasesPage(mozwebqa_logged_in)
manage_cases_pg.go_to_manage_cases_page()
filter_item = manage_cases_pg.filter_form.filter_by(
lookup='product', value=product['name'])
test_cases = manage_cases_pg.test_cases
#remember case version and delete case
deleted_version = test_cases[0].product_version
product_versions.remove(deleted_version)
test_cases[0].delete()
filter_item.remove_filter()
manage_cases_pg.filter_form.filter_by(lookup='name',
value=test_case['name'])
test_cases = manage_cases_pg.test_cases
#check that there is only one test case left and ensure its version equals to second version
Assert.equal(len(test_cases), 1, u'there should be only one case')
Assert.equal(test_cases[0].name, test_case['name'],
u'that\'s wrong test case')
Assert.equal(test_cases[0].product_version, product_versions[0],
u'that\'s wrong product version')
def test_that_deleting_single_version_of_case_does_not_delete_all_versions(
self, api, base_url, selenium, login, product):
# prerequisites
test_case = self.create_case(base_url,
selenium,
product=product,
api=api)
first_version = product['version']
second_version = self.create_version(base_url,
selenium,
product=product)
product_versions = [
u'%s %s' % (product['name'], version['name'])
for version in (first_version, second_version)
]
manage_cases_pg = MozTrapManageCasesPage(base_url, selenium)
manage_cases_pg.go_to_manage_cases_page()
filter_item = manage_cases_pg.filter_form.filter_by(
lookup='product', value=product['name'])
test_cases = manage_cases_pg.test_cases
# remember case version and delete case
deleted_version = test_cases[0].product_version
product_versions.remove(deleted_version)
test_cases[0].delete()
filter_item.remove_filter()
manage_cases_pg.filter_form.filter_by(lookup='name',
value=test_case['name'])
test_cases = manage_cases_pg.test_cases
# check that there is only one test case left and ensure its version equals to second version
assert 1 == len(test_cases)
assert test_case['name'] == test_cases[0].name
assert product_versions[0] == test_cases[0].product_version
def test_creating_a_tag_with_a_product_value_and_cases(self, api, base_url, selenium, login, product):
# create some cases for product
cases = self.create_bulk_cases(base_url, selenium, product, api=api)
manage_tags_pg = MozTrapManageTagsPage(base_url, selenium)
manage_tags_pg.go_to_manage_tags_page()
create_tag_pg = manage_tags_pg.click_create_tag_button()
tag = MockTag(product=product['name'])
create_tag_pg.create_tag(tag, save_tag=False)
expected_case_names = [case.name for case in cases]
actual_case_names = [case.name for case in create_tag_pg.available_caseversions]
assert sorted(expected_case_names) == sorted(actual_case_names)
create_tag_pg.include_caseversions_to_tag(expected_case_names)
manage_cases_page = MozTrapManageCasesPage(base_url, selenium)
manage_cases_page.go_to_manage_cases_page()
manage_cases_page.filter_form.filter_by(lookup='tag', value=tag['name'])
displayed_case_names = [case.name for case in manage_cases_page.test_cases]
assert sorted(expected_case_names) == sorted(displayed_case_names)
def test_that_creates_tag_during_test_case_creation(
self, mozwebqa, login, product):
mock_tag = MockTag()
mock_case = MockCase(tag=mock_tag)
test_case = self.create_case(mozwebqa,
product=product,
mock_case=mock_case)
manage_cases_pg = MozTrapManageCasesPage(mozwebqa)
manage_cases_pg.filter_form.filter_by(lookup='name',
value=test_case['name'])
filtered_cases = manage_cases_pg.test_cases
Assert.equal(len(filtered_cases), 1, u'there should be only one case')
Assert.equal(filtered_cases[0].tag_name, mock_tag['name'].lower(),
'actual tag name does not match expected value')
def test_that_creates_tag_during_test_case_creation(
self, base_url, selenium, login, product):
mock_tag = MockTag()
mock_case = MockCase(tag=mock_tag)
test_case = self.create_case(base_url,
selenium,
product=product,
mock_case=mock_case)
manage_cases_pg = MozTrapManageCasesPage(base_url, selenium)
manage_cases_pg.filter_form.filter_by(lookup='name',
value=test_case['name'])
filtered_cases = manage_cases_pg.test_cases
assert 1 == len(filtered_cases)
assert mock_tag['name'].lower() == filtered_cases[0].tag_name
def test_that_user_can_create_and_delete_case(self, mozwebqa_logged_in):
manage_cases_pg = MozTrapManageCasesPage(mozwebqa_logged_in)
case = self.create_case(mozwebqa_logged_in)
manage_cases_pg.filter_cases_by_name(name=case['name'])
Assert.true(manage_cases_pg.is_element_present(*case['locator']))
manage_cases_pg.delete_case(name=case['name'])
Assert.false(manage_cases_pg.is_element_present(*case['locator']))
self.delete_product(mozwebqa_logged_in, product=case['product'])
def test_that_pinning_filters_on_product_and_version_and_suite_set_defaults_in_new_case(
self, mozwebqa_logged_in, product):
version = product['version']
product_version_name = u'%s %s' % (product['name'], version['name'])
suite = self.create_suite(mozwebqa_logged_in,
product=product,
use_API=True)
manage_cases_pg = MozTrapManageCasesPage(mozwebqa_logged_in)
manage_cases_pg.go_to_manage_cases_page()
filters = []
filters.append(
manage_cases_pg.filter_form.filter_by(lookup='product',
value=product['name']))
filters.append(
manage_cases_pg.filter_form.filter_by(lookup='productversion',
value=product_version_name))
filters.append(
manage_cases_pg.filter_form.filter_by(lookup='suite',
value=suite['name']))
for item in filters:
item.pin_filter()
self.check_pinned_filter(item, is_pinned=True)
#go to create case page
create_case_pg = manage_cases_pg.click_create_case_button()
Assert.equal(create_case_pg.product_value, product['name'])
Assert.equal(create_case_pg.product_version_value, version['name'])
Assert.equal(create_case_pg.suite_value, suite['name'])
create_case_pg.go_back()
#go to create bulk cases page
create_bulk_cases_pg = manage_cases_pg.click_create_bulk_cases_button()
Assert.equal(create_bulk_cases_pg.product_value, product['name'])
Assert.equal(create_bulk_cases_pg.product_version_value,
version['name'])
Assert.equal(create_bulk_cases_pg.suite_value, suite['name'])
def test_that_pinning_filters_on_product_and_version_and_suite_set_defaults_in_new_case(
self, api, base_url, selenium, login, product):
version = product['version']
product_version_name = u'%s %s' % (product['name'], version['name'])
suite = self.create_suite(base_url, selenium, product=product, api=api)
manage_cases_pg = MozTrapManageCasesPage(base_url, selenium)
manage_cases_pg.go_to_manage_cases_page()
filters = []
filters.append(
manage_cases_pg.filter_form.filter_by(lookup='product',
value=product['name']))
filters.append(
manage_cases_pg.filter_form.filter_by(lookup='productversion',
value=product_version_name))
filters.append(
manage_cases_pg.filter_form.filter_by(lookup='suite',
value=suite['name']))
for item in filters:
item.pin_filter()
self.check_pinned_filter(item, is_pinned=True)
# go to create case page
create_case_pg = manage_cases_pg.click_create_case_button()
assert product['name'] == create_case_pg.product_value
assert version['name'] == create_case_pg.product_version_value
assert suite['name'] == create_case_pg.suite_value
create_case_pg.go_back()
# go to create bulk cases page
create_bulk_cases_pg = manage_cases_pg.click_create_bulk_cases_button()
assert product['name'] == create_bulk_cases_pg.product_value
assert version['name'] == create_bulk_cases_pg.product_version_value
assert suite['name'] == create_bulk_cases_pg.suite_value
def test_that_pinning_name_field_filter_only_works_for_current_page(
self, mozwebqa_logged_in, product):
good_case_name = u'mozilla'
good_suite_name = u'MozTrap'
self.create_bulk_cases(mozwebqa_logged_in,
product,
use_API=True,
name=good_case_name,
cases_amount=3)
self.create_bulk_cases(mozwebqa_logged_in,
product,
use_API=True,
name=u'ALLIZOM',
cases_amount=2)
self.create_suite(mozwebqa_logged_in,
product,
use_API=True,
name=good_suite_name)
self.create_suite(mozwebqa_logged_in,
product,
use_API=True,
name=u'PartZom')
manage_cases_pg = MozTrapManageCasesPage(mozwebqa_logged_in)
manage_cases_pg.go_to_manage_cases_page()
#filter cases by name and assert that only cases with mozilla in their name are found
cases_filter = manage_cases_pg.filter_form.filter_by(
lookup='name', value=good_case_name)
Assert.equal(cases_filter.content_text, good_case_name)
self.check_pinned_filter(cases_filter, is_pinned=False)
for case in manage_cases_pg.test_cases:
Assert.contains(good_case_name, case.name.lower())
#pin filter and assert that it turns orange
cases_filter.pin_filter()
self.check_pinned_filter(cases_filter, is_pinned=True)
manage_suites_pg = MozTrapManageSuitesPage(mozwebqa_logged_in)
manage_suites_pg.go_to_manage_suites_page()
#check that there is no filters applied
Assert.equal(manage_suites_pg.filter_form.filter_items, [])
#filter suites by name and assert that only suites with moztrap in their name are found
suites_filter = manage_suites_pg.filter_form.filter_by(
lookup='name', value=good_suite_name)
Assert.equal(suites_filter.content_text, good_suite_name.lower())
self.check_pinned_filter(suites_filter, is_pinned=False)
for suite in manage_suites_pg.test_suites:
Assert.contains(good_suite_name, suite.name)
#pin filter and assert that it turns orange
suites_filter.pin_filter()
self.check_pinned_filter(suites_filter, is_pinned=True)
#and check everything again on manage cases page
manage_cases_pg.go_to_manage_cases_page()
applied_filter = manage_cases_pg.filter_form.filter_items
Assert.equal(len(applied_filter), 1)
Assert.equal(applied_filter[0].content_text, good_case_name)
for case in manage_cases_pg.test_cases:
Assert.contains(good_case_name, case.name.lower())
#and check everything one more time on manage suites page
manage_suites_pg.go_to_manage_suites_page()
applied_filter = manage_suites_pg.filter_form.filter_items
Assert.equal(len(applied_filter), 1)
Assert.equal(applied_filter[0].content_text, good_suite_name.lower())
for suite in manage_suites_pg.test_suites:
Assert.contains(good_suite_name, suite.name)
#and go to manage runs page and see no filters there
manage_runs_pg = MozTrapManageRunsPage(mozwebqa_logged_in)
manage_runs_pg.go_to_manage_runs_page()
#check that there is no filters applied
Assert.equal(manage_runs_pg.filter_form.filter_items, [])
manage_tags_pg = MozTrapManageTagsPage(mozwebqa_logged_in)
manage_tags_pg.go_to_manage_tags_page()
create_tag_pg = manage_tags_pg.click_create_tag_button()
tag = MockTag(product=product['name'])
create_tag_pg.create_tag(tag, save_tag=False)
expected_case_names = [case.name for case in cases]
actual_case_names = [
case.name for case in create_tag_pg.available_caseversions
]
Assert.equal(
sorted(expected_case_names), sorted(actual_case_names),
'list of expected caseversions differs from actually displayed')
create_tag_pg.include_caseversions_to_tag(expected_case_names)
manage_cases_page = MozTrapManageCasesPage(mozwebqa_logged_in)
manage_cases_page.go_to_manage_cases_page()
manage_cases_page.filter_form.filter_by(lookup='tag',
value=tag['name'])
displayed_case_names = [
case.name for case in manage_cases_page.test_cases
]
Assert.equal(
sorted(expected_case_names), sorted(displayed_case_names),
'list of test cases attached to a tag differs from expected')
def test_that_pinning_name_field_filter_only_works_for_current_page(
self, api, base_url, selenium, login, product):
good_case_name = u'mozilla'
good_suite_name = u'MozTrap'
self.create_bulk_cases(base_url,
selenium,
product,
api=api,
name=good_case_name,
cases_amount=3)
self.create_bulk_cases(base_url,
selenium,
product,
api=api,
name=u'ALLIZOM',
cases_amount=2)
self.create_suite(base_url,
selenium,
product,
api=api,
name=good_suite_name)
self.create_suite(base_url,
selenium,
product,
api=api,
name=u'PartZom')
manage_cases_pg = MozTrapManageCasesPage(base_url, selenium)
manage_cases_pg.go_to_manage_cases_page()
# filter cases by name and assert that only cases with mozilla in their name are found
cases_filter = manage_cases_pg.filter_form.filter_by(
lookup='name', value=good_case_name)
assert good_case_name == cases_filter.content_text
self.check_pinned_filter(cases_filter, is_pinned=False)
for case in manage_cases_pg.test_cases:
assert good_case_name in case.name.lower()
# pin filter and assert that it turns orange
cases_filter.pin_filter()
self.check_pinned_filter(cases_filter, is_pinned=True)
manage_suites_pg = MozTrapManageSuitesPage(base_url, selenium)
manage_suites_pg.go_to_manage_suites_page()
# check that there is no filters applied
assert [] == manage_suites_pg.filter_form.filter_items
# filter suites by name and assert that only suites with moztrap in their name are found
suites_filter = manage_suites_pg.filter_form.filter_by(
lookup='name', value=good_suite_name)
assert good_suite_name.lower() == suites_filter.content_text
self.check_pinned_filter(suites_filter, is_pinned=False)
for suite in manage_suites_pg.test_suites:
assert good_suite_name in suite.name
# pin filter and assert that it turns orange
suites_filter.pin_filter()
self.check_pinned_filter(suites_filter, is_pinned=True)
# and check everything again on manage cases page
manage_cases_pg.go_to_manage_cases_page()
applied_filter = manage_cases_pg.filter_form.filter_items
assert 1 == len(applied_filter)
assert good_case_name == applied_filter[0].content_text
for case in manage_cases_pg.test_cases:
assert good_case_name in case.name.lower()
# and check everything one more time on manage suites page
manage_suites_pg.go_to_manage_suites_page()
applied_filter = manage_suites_pg.filter_form.filter_items
assert 1 == len(applied_filter)
assert good_suite_name.lower() == applied_filter[0].content_text
for suite in manage_suites_pg.test_suites:
assert good_suite_name in suite.name
# and go to manage runs page and see no filters there
manage_runs_pg = MozTrapManageRunsPage(base_url, selenium)
manage_runs_pg.go_to_manage_runs_page()
# check that there is no filters applied
assert [] == manage_runs_pg.filter_form.filter_items
def test_that_pinning_filter_persists_for_session(self, api, base_url,
selenium, existing_user,
login, product, element):
# create suite, cases and test run
product_version_name = u'%s %s' % (product['name'],
product['version']['name'])
case, suite, run = self.create_and_run_test(api, base_url, selenium,
product, element)
# go to manage cases page
manage_cases_pg = MozTrapManageCasesPage(base_url, selenium)
manage_cases_pg.go_to_manage_cases_page()
# filter on product
filter_item = manage_cases_pg.filter_form.filter_by(
lookup='product', value=product['name'])
self.check_pinned_filter(filter_item, is_pinned=False)
# see only cases for specified product
displayed_cases = manage_cases_pg.test_cases
assert 1 == len(displayed_cases)
assert case.name.lower() == displayed_cases[0].name.lower()
# pin product filter
filter_item.pin_filter()
self.check_pinned_filter(filter_item, is_pinned=True)
# go to manage suites page
manage_suites_pg = MozTrapManageSuitesPage(base_url, selenium)
manage_suites_pg.go_to_manage_suites_page()
# see only suites for specified product
displayed_suites = manage_suites_pg.test_suites
assert 1 == len(displayed_suites)
assert suite.name.lower() == displayed_suites[0].name.lower()
# go to results page
view_results_pg = MozTrapViewRunResultsPage(base_url, selenium)
view_results_pg.go_to_view_run_results_page()
# see only results for specified product
# because we are going to check the same thing several times
# let's define a function and call it each time we need this check
def check_test_run_results(results):
assert 1 == len(results)
assert run['name'].lower() == results[0].name.lower()
assert product_version_name == results[0].product_version
check_test_run_results(view_results_pg.test_run_results)
# refresh page and see that filter persists
view_results_pg.refresh()
check_test_run_results(view_results_pg.test_run_results)
# log out and back in and see that filter persists
view_results_pg.header.click_logout()
view_results_pg.header.login(existing_user['email'],
existing_user['password'])
check_test_run_results(view_results_pg.test_run_results)
# check that filter is still pinned
filters = view_results_pg.filter_form.filter_items
assert 1 == len(filters)
self.check_pinned_filter(filters[0], is_pinned=True)
def test_that_pinning_name_field_filter_only_works_for_current_page(self, api, mozwebqa, login, product):
good_case_name = u'mozilla'
good_suite_name = u'MozTrap'
self.create_bulk_cases(mozwebqa, product, api=api, name=good_case_name, cases_amount=3)
self.create_bulk_cases(mozwebqa, product, api=api, name=u'ALLIZOM', cases_amount=2)
self.create_suite(mozwebqa, product, api=api, name=good_suite_name)
self.create_suite(mozwebqa, product, api=api, name=u'PartZom')
manage_cases_pg = MozTrapManageCasesPage(mozwebqa)
manage_cases_pg.go_to_manage_cases_page()
# filter cases by name and assert that only cases with mozilla in their name are found
cases_filter = manage_cases_pg.filter_form.filter_by(lookup='name', value=good_case_name)
assert good_case_name == cases_filter.content_text
self.check_pinned_filter(cases_filter, is_pinned=False)
for case in manage_cases_pg.test_cases:
assert good_case_name in case.name.lower()
# pin filter and assert that it turns orange
cases_filter.pin_filter()
self.check_pinned_filter(cases_filter, is_pinned=True)
manage_suites_pg = MozTrapManageSuitesPage(mozwebqa)
manage_suites_pg.go_to_manage_suites_page()
# check that there is no filters applied
assert [] == manage_suites_pg.filter_form.filter_items
# filter suites by name and assert that only suites with moztrap in their name are found
suites_filter = manage_suites_pg.filter_form.filter_by(lookup='name', value=good_suite_name)
assert good_suite_name.lower() == suites_filter.content_text
self.check_pinned_filter(suites_filter, is_pinned=False)
for suite in manage_suites_pg.test_suites:
assert good_suite_name in suite.name
# pin filter and assert that it turns orange
suites_filter.pin_filter()
self.check_pinned_filter(suites_filter, is_pinned=True)
# and check everything again on manage cases page
manage_cases_pg.go_to_manage_cases_page()
applied_filter = manage_cases_pg.filter_form.filter_items
assert 1 == len(applied_filter)
assert good_case_name == applied_filter[0].content_text
for case in manage_cases_pg.test_cases:
assert good_case_name in case.name.lower()
# and check everything one more time on manage suites page
manage_suites_pg.go_to_manage_suites_page()
applied_filter = manage_suites_pg.filter_form.filter_items
assert 1 == len(applied_filter)
assert good_suite_name.lower() == applied_filter[0].content_text
for suite in manage_suites_pg.test_suites:
assert good_suite_name in suite.name
# and go to manage runs page and see no filters there
manage_runs_pg = MozTrapManageRunsPage(mozwebqa)
manage_runs_pg.go_to_manage_runs_page()
# check that there is no filters applied
assert [] == manage_runs_pg.filter_form.filter_items
def delete_case(self, base_url, selenium, case):
manage_cases_pg = MozTrapManageCasesPage(base_url, selenium)
manage_cases_pg.go_to_manage_cases_page()
manage_cases_pg.filter_form.filter_by(lookup='name', value=case['name'])
manage_cases_pg.delete_case(name=case['name'])
manage_tags_pg = MozTrapManageTagsPage(mozwebqa)
manage_tags_pg.go_to_manage_tags_page()
create_tag_pg = manage_tags_pg.click_create_tag_button()
tag = MockTag(product=product['name'])
create_tag_pg.create_tag(tag, save_tag=False)
expected_case_names = [case.name for case in cases]
actual_case_names = [
case.name for case in create_tag_pg.available_caseversions
]
Assert.equal(
sorted(expected_case_names), sorted(actual_case_names),
'list of expected caseversions differs from actually displayed')
create_tag_pg.include_caseversions_to_tag(expected_case_names)
manage_cases_page = MozTrapManageCasesPage(mozwebqa)
manage_cases_page.go_to_manage_cases_page()
manage_cases_page.filter_form.filter_by(lookup='tag',
value=tag['name'])
displayed_case_names = [
case.name for case in manage_cases_page.test_cases
]
Assert.equal(
sorted(expected_case_names), sorted(displayed_case_names),
'list of test cases attached to a tag differs from expected')
create_case_pg = MozTrapCreateCasePage(mozwebqa)
if product is None:
product = self.create_product(mozwebqa)
version = product['version']
elif version is None:
version = product['version']
create_case_pg.go_to_create_case_page()
case = create_case_pg.create_case(product=product['name'], version=version['name'], status=status, suite=suite_name)
case['product'] = product
return case
def delete_case(self, mozwebqa, case, delete_product=False):
manage_cases_pg = MozTrapManageCasesPage(mozwebqa)
manage_cases_pg.go_to_manage_cases_page()
manage_cases_pg.filter_cases_by_name(name=case['name'])
manage_cases_pg.delete_case(name=case['name'])
if delete_product:
self.delete_product(mozwebqa, product=case['product'])
def create_profile(self, mozwebqa):
create_profile_pg = MozTrapCreateProfilePage(mozwebqa)
create_profile_pg.go_to_create_profile_page()
profile = create_profile_pg.create_profile()
return profile
def test_that_pinning_filter_persists_for_session(self, mozwebqa_logged_in, product, element):
# create suite, cases and test run
product_version_name = u'%s %s' % (product['name'], product['version']['name'])
case, suite, run = self.create_and_run_test(mozwebqa_logged_in, product, element)
# go to manage cases page
manage_cases_pg = MozTrapManageCasesPage(mozwebqa_logged_in)
manage_cases_pg.go_to_manage_cases_page()
# filter on product
filter_item = manage_cases_pg.filter_form.filter_by(lookup='product', value=product['name'])
self.check_pinned_filter(filter_item, is_pinned=False)
# see only cases for specified product
displayed_cases = manage_cases_pg.test_cases
Assert.equal(len(displayed_cases), 1, 'there should be only one case displayed')
Assert.equal(case.name.lower(), displayed_cases[0].name.lower(),
'displayed case name differs from expected value')
# pin product filter
filter_item.pin_filter()
self.check_pinned_filter(filter_item, is_pinned=True)
# go to manage suites page
manage_suites_pg = MozTrapManageSuitesPage(mozwebqa_logged_in)
manage_suites_pg.go_to_manage_suites_page()
# see only suites for specified product
displayed_suites = manage_suites_pg.test_suites
Assert.equal(len(displayed_suites), 1, 'there should be only one suite displayed')
Assert.equal(suite.name.lower(), displayed_suites[0].name.lower(),
'displayed suite name differs from expected value')
# go to results page
view_results_pg = MozTrapViewRunResultsPage(mozwebqa_logged_in)
view_results_pg.go_to_view_run_results_page()
# see only results for specified product
# because we are going to check the same thing several times
# let's define a function and call it each time we need this check
def check_test_run_results(results):
Assert.equal(len(results), 1, 'there should be only one test run result')
Assert.equal(run['name'].lower(), results[0].name.lower(),
'displayed run name differs from expected value')
Assert.equal(product_version_name, results[0].product_version,
'displayed test run productversion differs from expected value')
check_test_run_results(view_results_pg.test_run_results)
# refresh page and see that filter persists
view_results_pg.refresh()
check_test_run_results(view_results_pg.test_run_results)
# log out and back in and see that filter persists
view_results_pg.header.click_logout()
view_results_pg.header.click_login()
check_test_run_results(view_results_pg.test_run_results)
# check that filter is still pinned
filters = view_results_pg.filter_form.filter_items
Assert.equal(len(filters), 1)
self.check_pinned_filter(filters[0], is_pinned=True)
def delete_case(self, mozwebqa, case):
manage_cases_pg = MozTrapManageCasesPage(mozwebqa)
manage_cases_pg.go_to_manage_cases_page()
manage_cases_pg.filter_form.filter_by(lookup='name', value=case['name'])
manage_cases_pg.delete_case(name=case['name'])
def view_cases(self):
self.find_element(*self._view_cases_locator).click()
from pages.manage_cases_page import MozTrapManageCasesPage
return MozTrapManageCasesPage(self.testsetup)
create_tag_pg.save_tag()
manage_tags_pg.filter_form.filter_by(lookup='name', value=tag['name'])
displayed_tags = manage_tags_pg.tags()
assert tag['name'] in [t.name for t in displayed_tags]
def test_creating_a_tag_with_a_product_value_and_cases(self, api, base_url, selenium, login, product):
# create some cases for product
cases = self.create_bulk_cases(base_url, selenium, product, api=api)
manage_tags_pg = MozTrapManageTagsPage(base_url, selenium)
manage_tags_pg.go_to_manage_tags_page()
create_tag_pg = manage_tags_pg.click_create_tag_button()
tag = MockTag(product=product['name'])
create_tag_pg.create_tag(tag, save_tag=False)
expected_case_names = [case.name for case in cases]
actual_case_names = [case.name for case in create_tag_pg.available_caseversions]
assert sorted(expected_case_names) == sorted(actual_case_names)
create_tag_pg.include_caseversions_to_tag(expected_case_names)
manage_cases_page = MozTrapManageCasesPage(base_url, selenium)
manage_cases_page.go_to_manage_cases_page()
manage_cases_page.filter_form.filter_by(lookup='tag', value=tag['name'])
displayed_case_names = [case.name for case in manage_cases_page.test_cases]
assert sorted(expected_case_names) == sorted(displayed_case_names)
def test_that_pinning_filter_persists_for_session(self, api, mozwebqa,
existing_user, login,
product, element):
# create suite, cases and test run
product_version_name = u'%s %s' % (product['name'],
product['version']['name'])
case, suite, run = self.create_and_run_test(api, mozwebqa, product,
element)
# go to manage cases page
manage_cases_pg = MozTrapManageCasesPage(mozwebqa)
manage_cases_pg.go_to_manage_cases_page()
# filter on product
filter_item = manage_cases_pg.filter_form.filter_by(
lookup='product', value=product['name'])
self.check_pinned_filter(filter_item, is_pinned=False)
# see only cases for specified product
displayed_cases = manage_cases_pg.test_cases
Assert.equal(len(displayed_cases), 1,
'there should be only one case displayed')
Assert.equal(case.name.lower(), displayed_cases[0].name.lower(),
'displayed case name differs from expected value')
# pin product filter
filter_item.pin_filter()
self.check_pinned_filter(filter_item, is_pinned=True)
# go to manage suites page
manage_suites_pg = MozTrapManageSuitesPage(mozwebqa)
manage_suites_pg.go_to_manage_suites_page()
# see only suites for specified product
displayed_suites = manage_suites_pg.test_suites
Assert.equal(len(displayed_suites), 1,
'there should be only one suite displayed')
Assert.equal(suite.name.lower(), displayed_suites[0].name.lower(),
'displayed suite name differs from expected value')
# go to results page
view_results_pg = MozTrapViewRunResultsPage(mozwebqa)
view_results_pg.go_to_view_run_results_page()
# see only results for specified product
# because we are going to check the same thing several times
# let's define a function and call it each time we need this check
def check_test_run_results(results):
Assert.equal(len(results), 1,
'there should be only one test run result')
Assert.equal(run['name'].lower(), results[0].name.lower(),
'displayed run name differs from expected value')
Assert.equal(
product_version_name, results[0].product_version,
'displayed test run productversion differs from expected value'
)
check_test_run_results(view_results_pg.test_run_results)
# refresh page and see that filter persists
view_results_pg.refresh()
check_test_run_results(view_results_pg.test_run_results)
# log out and back in and see that filter persists
view_results_pg.header.click_logout()
view_results_pg.header.login(existing_user['email'],
existing_user['password'])
check_test_run_results(view_results_pg.test_run_results)
# check that filter is still pinned
filters = view_results_pg.filter_form.filter_items
Assert.equal(len(filters), 1)
self.check_pinned_filter(filters[0], is_pinned=True)
def test_that_pinning_name_field_filter_only_works_for_current_page(self, mozwebqa_logged_in, product):
good_case_name = u'mozilla'
good_suite_name = u'MozTrap'
self.create_bulk_cases(mozwebqa_logged_in, product, use_API=True, name=good_case_name, cases_amount=3)
self.create_bulk_cases(mozwebqa_logged_in, product, use_API=True, name=u'ALLIZOM', cases_amount=2)
self.create_suite(mozwebqa_logged_in, product, use_API=True, name=good_suite_name)
self.create_suite(mozwebqa_logged_in, product, use_API=True, name=u'PartZom')
manage_cases_pg = MozTrapManageCasesPage(mozwebqa_logged_in)
manage_cases_pg.go_to_manage_cases_page()
#filter cases by name and assert that only cases with mozilla in their name are found
cases_filter = manage_cases_pg.filter_form.filter_by(lookup='name', value=good_case_name)
Assert.equal(cases_filter.content_text, good_case_name)
self.check_pinned_filter(cases_filter, is_pinned=False)
for case in manage_cases_pg.test_cases:
Assert.contains(good_case_name, case.name.lower())
#pin filter and assert that it turns orange
cases_filter.pin_filter()
self.check_pinned_filter(cases_filter, is_pinned=True)
manage_suites_pg = MozTrapManageSuitesPage(mozwebqa_logged_in)
manage_suites_pg.go_to_manage_suites_page()
#check that there is no filters applied
Assert.equal(manage_suites_pg.filter_form.filter_items, [])
#filter suites by name and assert that only suites with moztrap in their name are found
suites_filter = manage_suites_pg.filter_form.filter_by(lookup='name', value=good_suite_name)
Assert.equal(suites_filter.content_text, good_suite_name.lower())
self.check_pinned_filter(suites_filter, is_pinned=False)
for suite in manage_suites_pg.test_suites:
Assert.contains(good_suite_name, suite.name)
#pin filter and assert that it turns orange
suites_filter.pin_filter()
self.check_pinned_filter(suites_filter, is_pinned=True)
#and check everything again on manage cases page
manage_cases_pg.go_to_manage_cases_page()
applied_filter = manage_cases_pg.filter_form.filter_items
Assert.equal(len(applied_filter), 1)
Assert.equal(applied_filter[0].content_text, good_case_name)
for case in manage_cases_pg.test_cases:
Assert.contains(good_case_name, case.name.lower())
#and check everything one more time on manage suites page
manage_suites_pg.go_to_manage_suites_page()
applied_filter = manage_suites_pg.filter_form.filter_items
Assert.equal(len(applied_filter), 1)
Assert.equal(applied_filter[0].content_text, good_suite_name.lower())
for suite in manage_suites_pg.test_suites:
Assert.contains(good_suite_name, suite.name)
#and go to manage runs page and see no filters there
manage_runs_pg = MozTrapManageRunsPage(mozwebqa_logged_in)
manage_runs_pg.go_to_manage_runs_page()
#check that there is no filters applied
Assert.equal(manage_runs_pg.filter_form.filter_items, [])
