def test_that_pinning_filter_on_product_version_set_defaults_in_new_run(self, mozwebqa_logged_in): product = self.create_product(mozwebqa_logged_in) product_version_name = u'%s %s' % (product['name'], product['version']['name']) from pages.manage_runs_page import MozTrapManageRunsPage manage_runs_pg = MozTrapManageRunsPage(mozwebqa_logged_in) manage_runs_pg.go_to_manage_runs_page() filter_item = manage_runs_pg.filter_form.filter_by(lookup='productversion', value=product_version_name) #check that filter is not orange before it's pinned Assert.not_equal( filter_item.get_filter_color(), PINNED_FILTER_COLOR, u'filter is orange before it was pinned') filter_item.pin_filter() #check that filter is orange after it's been pinned Assert.equal( filter_item.get_filter_color(), PINNED_FILTER_COLOR, u'pinned filter\'s color is not orange') create_run_pg = manage_runs_pg.click_create_run_button() Assert.equal( create_run_pg.product_version_value, product_version_name, u'default product version is incorrect')
def delete_run(self, mozwebqa, run, delete_version=False, delete_product=False): manage_runs_pg = MozTrapManageRunsPage(mozwebqa) manage_runs_pg.go_to_manage_runs_page() manage_runs_pg.filter_form.filter_by(lookup='name', value=run['name']) manage_runs_pg.delete_run(name=run['name']) if delete_version: self.delete_version(mozwebqa, version=run['version'], delete_product=delete_product)
def delete_run(self, base_url, selenium, run, delete_version=False): manage_runs_pg = MozTrapManageRunsPage(base_url, selenium) manage_runs_pg.go_to_manage_runs_page() manage_runs_pg.filter_form.filter_by(lookup='name', value=run['name']) manage_runs_pg.delete_run(name=run['name']) if delete_version: self.delete_version(base_url, selenium, version=run['version'])
def test_that_user_can_create_and_delete_run(self, mozwebqa_logged_in, product): manage_runs_pg = MozTrapManageRunsPage(mozwebqa_logged_in) run = self.create_run(mozwebqa_logged_in, product=product) manage_runs_pg.filter_form.filter_by(lookup="name", value=run["name"]) Assert.true(manage_runs_pg.is_element_present(*run["manage_locator"])) manage_runs_pg.delete_run(name=run["name"]) Assert.false(manage_runs_pg.is_element_present(*run["manage_locator"]))
def test_that_user_can_create_and_delete_run(self, mozwebqa, login, product): manage_runs_pg = MozTrapManageRunsPage(mozwebqa) run = self.create_run(mozwebqa, product=product) manage_runs_pg.filter_form.filter_by(lookup='name', value=run['name']) assert manage_runs_pg.is_element_present(*run['manage_locator']) manage_runs_pg.delete_run(name=run['name']) assert not manage_runs_pg.is_element_present(*run['manage_locator'])
def test_that_user_can_create_and_delete_run(self, mozwebqa_logged_in): manage_runs_pg = MozTrapManageRunsPage(mozwebqa_logged_in) run = self.create_run(mozwebqa_logged_in) manage_runs_pg.filter_form.filter_by(lookup='name', value=run['name']) Assert.true(manage_runs_pg.is_element_present(*run['manage_locator'])) manage_runs_pg.delete_run(name=run['name']) Assert.false(manage_runs_pg.is_element_present(*run['manage_locator'])) self.delete_version(mozwebqa_logged_in, version=run['version'], delete_product=True)
def test_that_test_run_saves_right_order_of_test_cases(self, mozwebqa_logged_in): #get profile, product and version profile = self.create_profile(mozwebqa_logged_in) product = self.create_product(mozwebqa_logged_in, profile['name']) version = product['version'] #create several test case via bulk create cases = self.create_bulk_cases(mozwebqa_logged_in, cases_amount=5, product=product, name='is') #create first test suite suite_a_cases = (cases[3]['name'], cases[1]['name']) suite_a = self.create_suite( mozwebqa_logged_in, product=product, name='suite A', case_name_list=suite_a_cases) #create second test suite suite_b_cases = (cases[2]['name'], cases[0]['name'], cases[4]['name']) suite_b = self.create_suite( mozwebqa_logged_in, product=product, name='suite B', case_name_list=suite_b_cases) #create first test run (suite a, suite b) first_suite_order = (suite_a['name'], suite_b['name']) first_run = self.create_run( mozwebqa_logged_in, activate=True, product=product, version=version, suite_name_list=first_suite_order) #execute first test run home_page = MozTrapHomePage(mozwebqa_logged_in) home_page.go_to_home_page() home_page.go_to_run_test( product_name=product['name'], version_name=version['name'], run_name=first_run['name'], env_category=profile['category'], env_element=profile['element']) run_tests_pg = MozTrapRunTestsPage(mozwebqa_logged_in) actual_order = [(item.name, item.suite_name) for item in run_tests_pg.test_items] expected_order = [(case, suite) for case in suite_a_cases for suite in (suite_a['name'],)] + \ [(case, suite) for case in suite_b_cases for suite in (suite_b['name'],)] #assert that right order saved Assert.equal(actual_order, expected_order) #edit run to reorder suites manage_runs_pg = MozTrapManageRunsPage(mozwebqa_logged_in) manage_runs_pg.go_to_manage_runs_page() #push run into draft mode manage_runs_pg.filter_form.filter_by(lookup='name', value=first_run['name']) manage_runs_pg.make_run_draft(first_run['name']) #go to edit run page and reorder suites by name (suite b, suite a) edit_run_pg = manage_runs_pg.go_to_edit_run_page(first_run['name']) second_run = edit_run_pg.edit_run(first_run, reorder_suites=True) #make run active again manage_runs_pg.filter_form.filter_by(lookup='name', value=first_run['name']) manage_runs_pg.activate_run(first_run['name']) #execute run again home_page.go_to_home_page() home_page.go_to_run_test( product_name=product['name'], version_name=version['name'], run_name=first_run['name'], env_category=profile['category'], env_element=profile['element']) #check actual order of items on run tests page actual_order = [(item.name, item.suite_name) for item in run_tests_pg.test_items] expected_order = [(case, suite) for case in suite_b_cases for suite in (suite_b['name'],)] + \ [(case, suite) for case in suite_a_cases for suite in (suite_a['name'],)] #assert that right order saved Assert.equal(actual_order, expected_order)
def create_run(self, mozwebqa, product, activate=False, version=None, suite_name_list=None): create_run_pg = MozTrapCreateRunPage(mozwebqa) if version is None: version = self.create_version(mozwebqa, product=product) create_run_pg.go_to_create_run_page() product_version = u'%(product_name)s %(version_name)s' % {'product_name': product['name'], 'version_name': version['name']} run = create_run_pg.create_run(product_version=product_version, suite_list=suite_name_list) run['version'] = version if activate: manage_runs_pg = MozTrapManageRunsPage(mozwebqa) manage_runs_pg.filter_form.filter_by(lookup='name', value=run['name']) manage_runs_pg.activate_run(name=run['name']) return run
def test_that_pinning_filter_on_product_version_set_defaults_in_new_run(self, mozwebqa, login, product): product_version_name = u'%s %s' % (product['name'], product['version']['name']) manage_runs_pg = MozTrapManageRunsPage(mozwebqa) manage_runs_pg.go_to_manage_runs_page() filter_item = manage_runs_pg.filter_form.filter_by(lookup='productversion', value=product_version_name) # check that filter is not orange before it's pinned self.check_pinned_filter(filter_item, is_pinned=False) filter_item.pin_filter() # check that filter is orange after it's been pinned self.check_pinned_filter(filter_item, is_pinned=True) create_run_pg = manage_runs_pg.click_create_run_button() assert product_version_name == create_run_pg.product_version_value
def test_that_test_run_saves_right_order_of_test_cases(self, api, mozwebqa, login, product, element): self.connect_product_to_element(mozwebqa, product, element) version = product['version'] # create several test case via bulk create cases = self.create_bulk_cases(mozwebqa, product, api=api, cases_amount=5) # create first test suite suite_a_cases = (cases[3], cases[1]) suite_a = self.create_suite( mozwebqa, product=product, api=api, name='suite A', case_list=suite_a_cases) # create second test suite suite_b_cases = (cases[2], cases[0], cases[4]) suite_b = self.create_suite( mozwebqa, product=product, api=api, name='suite B', case_list=suite_b_cases) # create first test run (suite a, suite b) first_suite_order = (suite_a['name'], suite_b['name']) first_run = self.create_run( mozwebqa, product=product, activate=True, version=version, suite_name_list=first_suite_order) # execute first test run home_page = MozTrapHomePage(mozwebqa) home_page.go_to_home_page() home_page.go_to_run_test( product_name=product['name'], version_name=version['name'], run_name=first_run['name'], env_category_name=element['category']['name'], env_element_name=element['name']) run_tests_pg = MozTrapRunTestsPage(mozwebqa) actual_order = [(item.case_name, item.suite_name) for item in run_tests_pg.test_results] expected_order = [(case['name'], suite) for case in suite_a_cases for suite in (suite_a['name'],)] + \ [(case['name'], suite) for case in suite_b_cases for suite in (suite_b['name'],)] # assert that right order saved assert expected_order == actual_order # edit run to reorder suites manage_runs_pg = MozTrapManageRunsPage(mozwebqa) manage_runs_pg.go_to_manage_runs_page() # push run into draft mode manage_runs_pg.filter_form.filter_by(lookup='name', value=first_run['name']) manage_runs_pg.make_run_draft(first_run['name']) # go to edit run page and reorder suites by name (suite b, suite a) edit_run_pg = manage_runs_pg.go_to_edit_run_page(first_run['name']) edit_run_pg.edit_run(first_run, reorder_suites=True) # make run active again manage_runs_pg.activate_run(first_run['name']) # execute run again home_page.go_to_home_page() home_page.go_to_run_test( product_name=product['name'], version_name=version['name'], run_name=first_run['name'], env_category_name=element['category']['name'], env_element_name=element['name']) # check actual order of items on run tests page actual_order = [(item.case_name, item.suite_name) for item in run_tests_pg.test_results] expected_order = [(case['name'], suite) for case in suite_b_cases for suite in (suite_b['name'],)] + \ [(case['name'], suite) for case in suite_a_cases for suite in (suite_a['name'],)] # assert that right order saved assert expected_order == actual_order
def test_for_edit_active_run_that_includes_suites_to_be_sure_they_are_listed(self, mozwebqa_logged_in, product): # create version version = product["version"] # create two test suites suite_a = self.create_suite(mozwebqa_logged_in, product=product, use_API=True, name="suite A") suite_b = self.create_suite(mozwebqa_logged_in, product=product, use_API=True, name="suite B") # create test run suite_order = [suite_b["name"], suite_a["name"]] test_run = self.create_run(mozwebqa_logged_in, product=product, version=version, suite_name_list=suite_order) manage_runs_pg = MozTrapManageRunsPage(mozwebqa_logged_in) manage_runs_pg.go_to_manage_runs_page() manage_runs_pg.filter_form.filter_by(lookup="name", value=test_run["name"]) manage_runs_pg.activate_run(name=test_run["name"]) edit_run_pg = manage_runs_pg.go_to_edit_run_page(test_run["name"]) # assert that multiselect widget is not present thus suites list is readonly Assert.false(edit_run_pg.is_multiselect_widget_present, u"multiselect widget should not be present") # assert that order of suites is correct Assert.equal(suite_order, edit_run_pg.readonly_included_suites, u"suites are listed in wrong order") edit_run_pg.save_run() test_run = manage_runs_pg.test_runs[0] test_run.show_details() # assert that order of suites is still correct Assert.equal(suite_order, test_run.included_suites, u"suites are listed in wrong order")
def test_for_edit_active_run_that_includes_suites_to_be_sure_they_are_listed(self, api, mozwebqa, login, product): # create version version = product['version'] # create two test suites suite_a = self.create_suite(mozwebqa, product=product, api=api, name='suite A') suite_b = self.create_suite(mozwebqa, product=product, api=api, name='suite B') # create test run suite_order = [suite_b['name'], suite_a['name']] test_run = self.create_run( mozwebqa, product=product, version=version, suite_name_list=suite_order) manage_runs_pg = MozTrapManageRunsPage(mozwebqa) manage_runs_pg.go_to_manage_runs_page() manage_runs_pg.filter_form.filter_by(lookup='name', value=test_run['name']) manage_runs_pg.activate_run(name=test_run['name']) edit_run_pg = manage_runs_pg.go_to_edit_run_page(test_run['name']) # assert that multiselect widget is not present thus suites list is readonly assert not edit_run_pg.is_multiselect_widget_present # assert that order of suites is correct assert suite_order == edit_run_pg.readonly_included_suites edit_run_pg.save_run() test_run = manage_runs_pg.test_runs[0] test_run.show_details() # assert that order of suites is still correct assert suite_order == test_run.included_suites
def test_that_user_can_create_and_delete_run(self, mozwebqa_logged_in): manage_runs_pg = MozTrapManageRunsPage(mozwebqa_logged_in) run = self.create_run(mozwebqa_logged_in) manage_runs_pg.filter_runs_by_name(name=run['name']) Assert.true(manage_runs_pg.is_element_present(*run['manage_locator'])) manage_runs_pg.delete_run(name=run['name']) Assert.false(manage_runs_pg.is_element_present(*run['manage_locator'])) self.delete_version(mozwebqa_logged_in, version=run['version'], delete_product=True)
def delete_run(self, mozwebqa, run, delete_version=False): manage_runs_pg = MozTrapManageRunsPage(mozwebqa) manage_runs_pg.go_to_manage_runs_page() manage_runs_pg.filter_form.filter_by(lookup='name', value=run['name']) manage_runs_pg.delete_run(name=run['name']) if delete_version: self.delete_version(mozwebqa, version=run['version'])
def test_that_user_can_create_and_delete_run(self, mozwebqa_logged_in, product): manage_runs_pg = MozTrapManageRunsPage(mozwebqa_logged_in) run = self.create_run(mozwebqa_logged_in, product=product) manage_runs_pg.filter_form.filter_by(lookup='name', value=run['name']) Assert.true(manage_runs_pg.is_element_present(*run['manage_locator'])) manage_runs_pg.delete_run(name=run['name']) Assert.false(manage_runs_pg.is_element_present(*run['manage_locator']))
def test_that_user_can_create_and_delete_run(self, base_url, selenium, login, product): manage_runs_pg = MozTrapManageRunsPage(base_url, selenium) run = self.create_run(base_url, selenium, product=product) manage_runs_pg.filter_form.filter_by(lookup='name', value=run['name']) assert manage_runs_pg.is_element_present(*run['manage_locator']) manage_runs_pg.delete_run(name=run['name']) assert not manage_runs_pg.is_element_present(*run['manage_locator'])
def test_for_edit_active_run_that_includes_suites_to_be_sure_they_are_listed( self, mozwebqa_logged_in, product): #create version version = product['version'] #create two test suites suite_a = self.create_suite(mozwebqa_logged_in, product=product, use_API=True, name='suite A') suite_b = self.create_suite(mozwebqa_logged_in, product=product, use_API=True, name='suite B') #create test run suite_order = [suite_b['name'], suite_a['name']] test_run = self.create_run(mozwebqa_logged_in, product=product, version=version, suite_name_list=suite_order) manage_runs_pg = MozTrapManageRunsPage(mozwebqa_logged_in) manage_runs_pg.go_to_manage_runs_page() manage_runs_pg.filter_form.filter_by(lookup='name', value=test_run['name']) manage_runs_pg.activate_run(name=test_run['name']) edit_run_pg = manage_runs_pg.go_to_edit_run_page(test_run['name']) #assert that multiselect widget is not present thus suites list is readonly Assert.false(edit_run_pg.is_multiselect_widget_present, u'multiselect widget should not be present') #assert that order of suites is correct Assert.equal(suite_order, edit_run_pg.readonly_included_suites, u'suites are listed in wrong order') edit_run_pg.save_run() manage_runs_pg.filter_form.filter_by(lookup='name', value=test_run['name']) test_run = manage_runs_pg.test_runs[0] test_run.show_details() #assert that order of suites is still correct Assert.equal(suite_order, test_run.included_suites, u'suites are listed in wrong order')
def test_for_edit_active_run_that_includes_suites_to_be_sure_they_are_listed( self, api, base_url, selenium, login, product): # create version version = product['version'] # create two test suites suite_a = self.create_suite(base_url, selenium, product=product, api=api, name='suite A') suite_b = self.create_suite(base_url, selenium, product=product, api=api, name='suite B') # create test run suite_order = [suite_b['name'], suite_a['name']] test_run = self.create_run(base_url, selenium, product=product, version=version, suite_name_list=suite_order) manage_runs_pg = MozTrapManageRunsPage(base_url, selenium) manage_runs_pg.go_to_manage_runs_page() manage_runs_pg.filter_form.filter_by(lookup='name', value=test_run['name']) manage_runs_pg.activate_run(name=test_run['name']) edit_run_pg = manage_runs_pg.go_to_edit_run_page(test_run['name']) # assert that multiselect widget is not present thus suites list is readonly assert not edit_run_pg.is_multiselect_widget_present # assert that order of suites is correct assert suite_order == edit_run_pg.readonly_included_suites edit_run_pg.save_run() test_run = manage_runs_pg.test_runs[0] test_run.show_details() # assert that order of suites is still correct assert suite_order == test_run.included_suites
def create_run(self, mozwebqa, activate=False, product=None, version=None, suite_name_list=None): create_run_pg = MozTrapCreateRunPage(mozwebqa) if version is None: version = self.create_version(mozwebqa, product=product) if product is None: product = version['product'] create_run_pg.go_to_create_run_page() product_version = u'%(product_name)s %(version_name)s' % {'product_name': product['name'], 'version_name': version['name']} run = create_run_pg.create_run(product_version=product_version, suite_list=suite_name_list) run['version'] = version if activate: manage_runs_pg = MozTrapManageRunsPage(mozwebqa) manage_runs_pg.filter_runs_by_name(name=run['name']) manage_runs_pg.activate_run(name=run['name']) return run
def test_for_edit_active_run_that_includes_suites_to_be_sure_they_are_listed(self, mozwebqa_logged_in): #create product and version product = self.create_product(mozwebqa_logged_in) version = product['version'] #create two test suites suite_a = self.create_suite(mozwebqa_logged_in, product=product, name='suite A') suite_b = self.create_suite(mozwebqa_logged_in, product=product, name='suite B') #create test run suite_order = [suite_b['name'], suite_a['name']] test_run = self.create_run( mozwebqa_logged_in, product=product, version=version, suite_name_list=suite_order) manage_runs_pg = MozTrapManageRunsPage(mozwebqa_logged_in) manage_runs_pg.go_to_manage_runs_page() manage_runs_pg.filter_form.filter_by(lookup='name', value=test_run['name']) manage_runs_pg.activate_run(name=test_run['name']) edit_run_pg = manage_runs_pg.go_to_edit_run_page(test_run['name']) #assert that multiselect widget is not present thus suites list is readonly Assert.false( edit_run_pg.is_multiselect_widget_present, u'multiselect widget should not be present') #assert that order of suites is correct Assert.equal( suite_order, edit_run_pg.readonly_included_suites, u'suites are listed in wrong order') edit_run_pg.save_run() manage_runs_pg.filter_form.filter_by(lookup='name', value=test_run['name']) test_run = manage_runs_pg.test_runs[0] test_run.show_details() #assert that order of suites is still correct Assert.equal( suite_order, test_run.included_suites, u'suites are listed in wrong order')
def click_manage_locator(self): self.selenium.find_element(*self._manage_locator).click() from pages.manage_runs_page import MozTrapManageRunsPage return MozTrapManageRunsPage(self.base_url, self.selenium)
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, [])
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_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, [])
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 test_that_test_run_saves_right_order_of_test_cases( self, mozwebqa_logged_in, product, element): self.connect_product_to_element(mozwebqa_logged_in, product, element) version = product['version'] # create several test case via bulk create cases = self.create_bulk_cases(mozwebqa_logged_in, product, use_API=True, cases_amount=5) # create first test suite suite_a_cases = (cases[3], cases[1]) suite_a = self.create_suite(mozwebqa_logged_in, product=product, use_API=True, name='suite A', case_list=suite_a_cases) # create second test suite suite_b_cases = (cases[2], cases[0], cases[4]) suite_b = self.create_suite(mozwebqa_logged_in, product=product, use_API=True, name='suite B', case_list=suite_b_cases) # create first test run (suite a, suite b) first_suite_order = (suite_a['name'], suite_b['name']) first_run = self.create_run(mozwebqa_logged_in, product=product, activate=True, version=version, suite_name_list=first_suite_order) # execute first test run home_page = MozTrapHomePage(mozwebqa_logged_in) home_page.go_to_home_page() home_page.go_to_run_test(product_name=product['name'], version_name=version['name'], run_name=first_run['name'], env_category_name=element['category']['name'], env_element_name=element['name']) run_tests_pg = MozTrapRunTestsPage(mozwebqa_logged_in) actual_order = [(item.case_name, item.suite_name) for item in run_tests_pg.test_results] expected_order = [(case['name'], suite) for case in suite_a_cases for suite in (suite_a['name'],)] + \ [(case['name'], suite) for case in suite_b_cases for suite in (suite_b['name'],)] # assert that right order saved Assert.equal(actual_order, expected_order) # edit run to reorder suites manage_runs_pg = MozTrapManageRunsPage(mozwebqa_logged_in) manage_runs_pg.go_to_manage_runs_page() # push run into draft mode manage_runs_pg.filter_form.filter_by(lookup='name', value=first_run['name']) manage_runs_pg.make_run_draft(first_run['name']) # go to edit run page and reorder suites by name (suite b, suite a) edit_run_pg = manage_runs_pg.go_to_edit_run_page(first_run['name']) edit_run_pg.edit_run(first_run, reorder_suites=True) # make run active again manage_runs_pg.activate_run(first_run['name']) # execute run again home_page.go_to_home_page() home_page.go_to_run_test(product_name=product['name'], version_name=version['name'], run_name=first_run['name'], env_category_name=element['category']['name'], env_element_name=element['name']) # check actual order of items on run tests page actual_order = [(item.case_name, item.suite_name) for item in run_tests_pg.test_results] expected_order = [(case['name'], suite) for case in suite_b_cases for suite in (suite_b['name'],)] + \ [(case['name'], suite) for case in suite_a_cases for suite in (suite_a['name'],)] # assert that right order saved Assert.equal(actual_order, expected_order)