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 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, 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 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_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_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, 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_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_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_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_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_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
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_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_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)
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 view_cases(self): self.find_element(*self._view_cases_locator).click() from pages.manage_cases_page import MozTrapManageCasesPage return MozTrapManageCasesPage(self.testsetup)
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, 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, [])