예제 #1
0
    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
예제 #2
0
    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'])
예제 #3
0
    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_runs_by_name(name=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']))
예제 #6
0
    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'])
예제 #7
0
    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)
예제 #8
0
    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_that_pinning_filter_on_product_version_set_defaults_in_new_run(
            self, base_url, selenium, login, product):
        product_version_name = u'%s %s' % (product['name'],
                                           product['version']['name'])

        manage_runs_pg = MozTrapManageRunsPage(base_url, selenium)
        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
예제 #10
0
    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
예제 #11
0
    def test_that_pinning_filter_on_product_version_set_defaults_in_new_run(
            self, mozwebqa_logged_in, product):
        product_version_name = u'%s %s' % (product['name'],
                                           product['version']['name'])

        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
        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.equal(create_run_pg.product_version_value, product_version_name,
                     u'default product version is incorrect')
예제 #12
0
 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, 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
예제 #14
0
    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)
예제 #15
0
    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, [])