Beispiel #1
0
    def test_positive_remove_hostgroup(self):
        """Add a hostgroup and remove it by using the location name and
        hostgroup name

        @feature: Locations

        @assert: hostgroup is added to location then removed
        """
        strategy, value = common_locators['all_values_selection']
        with Session(self.browser) as session:
            for host_grp_name in generate_strings_list():
                with self.subTest(host_grp_name):
                    loc_name = gen_string('alpha')
                    host_grp = entities.HostGroup(name=host_grp_name).create()
                    self.assertEqual(host_grp.name, host_grp_name)
                    set_context(session, org=ANY_CONTEXT['org'])
                    make_loc(session, name=loc_name)
                    self.location.search(loc_name).click()
                    session.nav.click(tab_locators['context.tab_hostgrps'])
                    element = session.nav.wait_until_element(
                        (strategy, value % host_grp_name))
                    # Item is listed in 'Selected Items' list and not
                    # 'All Items' list.
                    self.assertIsNotNone(element)
                    self.hostgroup.delete(host_grp_name)
                    self.location.search(loc_name).click()
                    session.nav.click(tab_locators['context.tab_hostgrps'])
                    element = session.nav.wait_until_element(
                        (strategy, value % host_grp_name))
                    # Item is listed in 'All Items' list and not
                    # 'Selected Items' list.
                    self.assertIsNone(element)
Beispiel #2
0
    def test_positive_remove_domain(self):
        """Add a domain to an location and remove it by location name
        and domain name

        @feature: Locations

        @assert: the domain is removed from the location
        """
        strategy, value = common_locators['entity_select']
        strategy1, value1 = common_locators['entity_deselect']
        with Session(self.browser) as session:
            for domain_name in generate_strings_list():
                with self.subTest(domain_name):
                    loc_name = gen_string('alpha')
                    domain = entities.Domain(name=domain_name).create()
                    self.assertEqual(domain.name, domain_name)
                    set_context(session, org=ANY_CONTEXT['org'])
                    make_loc(session, name=loc_name, domains=[domain_name])
                    self.location.search(loc_name).click()
                    session.nav.click(tab_locators['context.tab_domains'])
                    element = session.nav.wait_until_element(
                        (strategy1, value1 % domain_name))
                    # Item is listed in 'Selected Items' list and not
                    # 'All Items' list.
                    self.assertIsNotNone(element)
                    self.location.update(loc_name, domains=[domain_name])
                    self.location.search(loc_name).click()
                    session.nav.click(tab_locators['context.tab_domains'])
                    element = session.nav.wait_until_element(
                        (strategy, value % domain_name))
                    # Item is listed in 'All Items' list and not
                    # 'Selected Items' list.
                    self.assertIsNotNone(element)
Beispiel #3
0
    def test_positive_remove_environment(self):
        """Remove environment by using location name & environment name

        @feature: Locations

        @assert: environment is removed from Location
        """
        strategy, value = common_locators['entity_select']
        strategy1, value1 = common_locators['entity_deselect']
        with Session(self.browser) as session:
            for env_name in valid_env_names():
                with self.subTest(env_name):
                    loc_name = gen_string('alpha')
                    env = entities.Environment(name=env_name).create()
                    self.assertEqual(env.name, env_name)
                    set_context(session, org=ANY_CONTEXT['org'])
                    make_loc(session, name=loc_name, envs=[env_name])
                    self.location.search(loc_name).click()
                    session.nav.click(tab_locators['context.tab_env'])
                    element = session.nav.wait_until_element(
                        (strategy1, value1 % env_name))
                    # Item is listed in 'Selected Items' list and not
                    # 'All Items' list.
                    self.assertIsNotNone(element)
                    self.location.update(loc_name, envs=[env_name])
                    self.location.search(loc_name).click()
                    session.nav.click(tab_locators['context.tab_env'])
                    element = session.nav.wait_until_element(
                        (strategy, value % env_name))
                    # Item is listed in 'All Items' list and not
                    # 'Selected Items' list.
                    self.assertIsNotNone(element)
Beispiel #4
0
    def test_positive_add_template(self):
        """Add config template by using location name and config
        template name.

        @feature: Locations

        @assert: config template is added.
        """
        strategy, value = common_locators['all_values_selection']
        with Session(self.browser) as session:
            for template in generate_strings_list():
                with self.subTest(template):
                    loc_name = gen_string('alpha')
                    make_loc(session, name=loc_name)
                    self.assertIsNotNone(self.location.search(loc_name))
                    make_templates(
                        session,
                        name=template,
                        template_path=get_data_file(OS_TEMPLATE_DATA_FILE),
                        custom_really=True,
                        template_type='provision',
                    )
                    self.assertIsNotNone(self.template.search(template))
                    self.location.search(loc_name).click()
                    session.nav.click(tab_locators['context.tab_template'])
                    element = session.nav.wait_until_element(
                        (strategy, value % template))
                    self.assertIsNotNone(element)
Beispiel #5
0
    def test_positive_remove_compresource(self):
        """Remove compute resource by using the location name and
        compute resource name

        @feature: Locations

        @assert: compute resource is added then removed
        """
        strategy, value = common_locators['entity_select']
        strategy1, value1 = common_locators['entity_deselect']
        with Session(self.browser) as session:
            for resource_name in generate_strings_list():
                with self.subTest(resource_name):
                    loc_name = gen_string('alpha')
                    url = LIBVIRT_RESOURCE_URL % settings.server.hostname
                    resource = entities.LibvirtComputeResource(
                        name=resource_name, url=url).create()
                    self.assertEqual(resource.name, resource_name)
                    set_context(session, org=ANY_CONTEXT['org'])
                    make_loc(session, name=loc_name, resources=[resource_name])
                    self.location.search(loc_name).click()
                    session.nav.click(tab_locators['context.tab_resources'])
                    element = self.location.wait_until_element(
                        (strategy1, value1 % resource_name))
                    # Item is listed in 'Selected Items' list and not
                    # 'All Items' list.
                    self.assertIsNotNone(element)
                    self.location.update(loc_name, resources=[resource_name])
                    self.location.search(loc_name).click()
                    session.nav.click(tab_locators['context.tab_resources'])
                    element = session.nav.wait_until_element(
                        (strategy, value % resource_name))
                    # Item is listed in 'All Items' list and not
                    # 'Selected Items' list.
                    self.assertIsNotNone(element)
Beispiel #6
0
    def test_positive_remove_subnet(self):
        """Remove subnet by using location name and subnet name

        @feature: Locations

        @assert: subnet is added then removed
        """
        strategy, value = common_locators["entity_select"]
        strategy1, value1 = common_locators["entity_deselect"]
        with Session(self.browser) as session:
            for subnet_name in generate_strings_list():
                with self.subTest(subnet_name):
                    loc_name = gen_string("alpha")
                    subnet = entities.Subnet(
                        name=subnet_name, network=gen_ipaddr(ip3=True), mask="255.255.255.0"
                    ).create()
                    self.assertEqual(subnet.name, subnet_name)
                    set_context(session, org=ANY_CONTEXT["org"])
                    make_loc(session, name=loc_name, subnets=[subnet_name])
                    self.location.search(loc_name).click()
                    session.nav.click(tab_locators["context.tab_subnets"])
                    element = session.nav.wait_until_element((strategy1, value1 % subnet_name))
                    # Item is listed in 'Selected Items' list and not
                    # 'All Items' list.
                    self.assertIsNotNone(element)
                    self.location.update(loc_name, subnets=[subnet_name])
                    self.location.search(loc_name).click()
                    self.location.click(tab_locators["context.tab_subnets"])
                    element = session.nav.wait_until_element((strategy, value % subnet_name))
                    # Item is listed in 'All Items' list and not
                    # 'Selected Items' list.
                    self.assertIsNotNone(element)
Beispiel #7
0
    def test_positive_remove_hostgroup(self):
        """Add a hostgroup and remove it by using the location name and
        hostgroup name

        @feature: Locations

        @assert: hostgroup is added to location then removed
        """
        strategy, value = common_locators['all_values_selection']
        with Session(self.browser) as session:
            for host_grp_name in generate_strings_list():
                with self.subTest(host_grp_name):
                    loc_name = gen_string('alpha')
                    host_grp = entities.HostGroup(name=host_grp_name).create()
                    self.assertEqual(host_grp.name, host_grp_name)
                    set_context(session, org=ANY_CONTEXT['org'])
                    make_loc(session, name=loc_name)
                    self.location.search(loc_name).click()
                    session.nav.click(tab_locators['context.tab_hostgrps'])
                    element = session.nav.wait_until_element(
                        (strategy, value % host_grp_name))
                    # Item is listed in 'Selected Items' list and not
                    # 'All Items' list.
                    self.assertIsNotNone(element)
                    self.hostgroup.delete(host_grp_name)
                    self.location.search(loc_name).click()
                    session.nav.click(tab_locators['context.tab_hostgrps'])
                    element = session.nav.wait_until_element(
                        (strategy, value % host_grp_name))
                    # Item is listed in 'All Items' list and not
                    # 'Selected Items' list.
                    self.assertIsNone(element)
Beispiel #8
0
    def test_remove_medium(self, medium_name):
        """@test: Remove medium by using location name and medium name

        @feature: Locations

        @assert: medium is added then removed

        """
        strategy, value = common_locators['entity_select']
        strategy1, value1 = common_locators['entity_deselect']
        loc_name = gen_string('alpha')
        medium = entities.Media(
            name=medium_name,
            path_=INSTALL_MEDIUM_URL % gen_string('alpha', 6),
            os_family='Redhat',
        ).create()
        self.assertEqual(medium.name, medium_name)
        with Session(self.browser) as session:
            set_context(session, org=ANY_CONTEXT['org'])
            make_loc(session, name=loc_name, medias=[medium_name])
            self.location.search(loc_name).click()
            session.nav.click(tab_locators['context.tab_media'])
            element = session.nav.wait_until_element(
                (strategy1, value1 % medium_name))
            # Item is listed in 'Selected Items' list and not 'All Items' list.
            self.assertIsNotNone(element)
            self.location.update(loc_name, medias=[medium_name])
            self.location.search(loc_name).click()
            session.nav.click(tab_locators['context.tab_media'])
            element = session.nav.wait_until_element(
                (strategy, value % medium_name))
            # Item is listed in 'All Items' list and not 'Selected Items' list.
            self.assertIsNotNone(element)
Beispiel #9
0
    def test_remove_computeresource(self, resource_name):
        """@test: Remove compute resource by using the location name and
        compute resource name

        @feature: Locations

        @assert: compute resource is added then removed

        """
        strategy, value = common_locators['entity_select']
        strategy1, value1 = common_locators['entity_deselect']
        loc_name = gen_string('alpha')
        url = (LIBVIRT_RESOURCE_URL % conf.properties['main.server.hostname'])
        resource = entities.LibvirtComputeResource(
            name=resource_name, url=url).create()
        self.assertEqual(resource.name, resource_name)
        with Session(self.browser) as session:
            set_context(session, org=ANY_CONTEXT['org'])
            make_loc(session, name=loc_name, resources=[resource_name])
            self.location.search(loc_name).click()
            session.nav.click(tab_locators['context.tab_resources'])
            element = self.location.wait_until_element(
                (strategy1, value1 % resource_name))
            # Item is listed in 'Selected Items' list and not 'All Items' list.
            self.assertIsNotNone(element)
            self.location.update(loc_name, resources=[resource_name])
            self.location.search(loc_name).click()
            session.nav.click(tab_locators['context.tab_resources'])
            element = session.nav.wait_until_element(
                (strategy, value % resource_name))
            # Item is listed in 'All Items' list and not 'Selected Items' list.
            self.assertIsNotNone(element)
Beispiel #10
0
    def test_positive_add_subnet(self):
        """Add a subnet by using location name and subnet name

        :id: fe70ffba-e594-48d5-b2c5-be93e827cc60

        :expectedresults: subnet is added

        :CaseLevel: Integration
        """
        strategy, value = common_locators['entity_deselect']
        with Session(self.browser) as session:
            for subnet_name in generate_strings_list():
                with self.subTest(subnet_name):
                    loc_name = gen_string('alpha')
                    subnet = entities.Subnet(
                        name=subnet_name,
                        network=gen_ipaddr(ip3=True),
                        mask='255.255.255.0',
                    ).create()
                    self.assertEqual(subnet.name, subnet_name)
                    make_loc(session, name=loc_name)
                    self.assertIsNotNone(self.location.search(loc_name))
                    self.location.update(loc_name, new_subnets=[subnet_name])
                    self.location.search_and_click(loc_name)
                    session.nav.click(tab_locators['context.tab_subnets'])
                    element = session.nav.wait_until_element(
                        (strategy, value % subnet_name))
                    self.assertIsNotNone(element)
Beispiel #11
0
    def test_positive_add_subnet(self):
        """Add a subnet by using location name and subnet name

        @feature: Locations

        @assert: subnet is added
        """
        strategy, value = common_locators['entity_deselect']
        with Session(self.browser) as session:
            for subnet_name in generate_strings_list():
                with self.subTest(subnet_name):
                    loc_name = gen_string('alpha')
                    subnet = entities.Subnet(
                        name=subnet_name,
                        network=gen_ipaddr(ip3=True),
                        mask='255.255.255.0',
                    ).create()
                    self.assertEqual(subnet.name, subnet_name)
                    make_loc(session, name=loc_name)
                    self.assertIsNotNone(self.location.search(loc_name))
                    self.location.update(loc_name, new_subnets=[subnet_name])
                    self.location.search(loc_name).click()
                    session.nav.click(tab_locators['context.tab_subnets'])
                    element = session.nav.wait_until_element(
                        (strategy, value % subnet_name))
                    self.assertIsNotNone(element)
Beispiel #12
0
    def test_positive_add_template(self):
        """Add config template by using location name and config template name.

        :id: 8faf60d1-f4d6-4a58-a484-606a42957ce7

        :expectedresults: config template is added.

        :CaseLevel: Integration
        """
        strategy, value = common_locators['all_values_selection']
        with Session(self.browser) as session:
            for template in generate_strings_list():
                with self.subTest(template):
                    loc_name = gen_string('alpha')
                    make_loc(session, name=loc_name)
                    self.assertIsNotNone(self.location.search(loc_name))
                    make_templates(
                        session,
                        name=template,
                        template_path=get_data_file(OS_TEMPLATE_DATA_FILE),
                        custom_really=True,
                        template_type='Provisioning template',
                    )
                    self.assertIsNotNone(self.template.search(template))
                    self.location.search_and_click(loc_name)
                    session.nav.click(tab_locators['context.tab_template'])
                    element = session.nav.wait_until_element(
                        (strategy, value % template))
                    self.assertIsNotNone(element)
Beispiel #13
0
    def test_add_configtemplate_1(self, template):
        """@test: Add config template by using location name and
        configtemplate name.

        @feature: Locations

        @assert: configtemplate is added.

        """
        strategy, value = common_locators["all_values_selection"]
        loc_name = gen_string("alpha", 8)
        temp_type = 'provision'
        template_path = get_data_file(OS_TEMPLATE_DATA_FILE)
        with Session(self.browser) as session:
            make_loc(session, name=loc_name)
            self.assertIsNotNone(self.location.search(loc_name))
            make_templates(session, name=template, template_path=template_path,
                           custom_really=True, template_type=temp_type)
            self.assertIsNotNone(self.template.search(template))
            self.location.search(loc_name).click()
            session.nav.wait_until_element(
                tab_locators["context.tab_template"]).click()
            element = session.nav.wait_until_element((strategy,
                                                      value % template))
            self.assertIsNotNone(element)
Beispiel #14
0
    def test_positive_add_user(self):
        """Create user then add that user by using the location name

        :id: bf9b3fc2-6193-4edc-aaec-cd7b87f0804c

        :expectedresults: User is added to location

        :CaseLevel: Integration
        """
        strategy, value = common_locators['entity_deselect']
        with Session(self.browser) as session:
            # User names does not accept html values
            for user_name in generate_strings_list(length=10,
                                                   exclude_types=['html']):
                with self.subTest(user_name):
                    loc_name = gen_string('alpha')
                    password = gen_string('alpha')
                    user = entities.User(
                        login=user_name,
                        firstname=user_name,
                        lastname=user_name,
                        password=password,
                    ).create()
                    self.assertEqual(user.login, user_name)
                    make_loc(session, name=loc_name)
                    self.assertIsNotNone(self.location.search(loc_name))
                    self.location.update(loc_name, new_users=[user_name])
                    self.location.search_and_click(loc_name)
                    session.nav.click(tab_locators['context.tab_users'])
                    element = session.nav.wait_until_element(
                        (strategy, value % user_name))
                    self.assertIsNotNone(element)
Beispiel #15
0
    def test_positive_add_compresource(self):
        """Add compute resource using the location name and compute resource
        name

        :id: 1d24414a-666d-490d-89b9-cd0704684cdd

        :expectedresults: compute resource is added successfully

        :CaseLevel: Integration
        """
        strategy, value = common_locators['entity_deselect']
        with Session(self.browser) as session:
            for resource_name in generate_strings_list():
                with self.subTest(resource_name):
                    loc_name = gen_string('alpha')
                    url = (LIBVIRT_RESOURCE_URL %
                           settings.compute_resources.libvirt_hostname)
                    resource = entities.LibvirtComputeResource(
                        name=resource_name, url=url).create()
                    self.assertEqual(resource.name, resource_name)
                    make_loc(session, name=loc_name)
                    self.assertIsNotNone(self.location.search(loc_name))
                    self.location.update(loc_name,
                                         new_resources=[resource_name])
                    self.location.search_and_click(loc_name)
                    session.nav.click(tab_locators['context.tab_resources'])
                    element = session.nav.wait_until_element(
                        (strategy, value % resource_name))
                    self.assertIsNotNone(element)
Beispiel #16
0
    def test_positive_remove_user(self):
        """Create admin users then add user and remove it by using the
        location name

        @feature: Locations

        @assert: The user is added then removed from the location
        """
        strategy, value = common_locators["entity_select"]
        strategy1, value1 = common_locators["entity_deselect"]
        with Session(self.browser) as session:
            # User names does not accept html values
            for user_name in generate_strings_list(length=10, exclude_types=["html"]):
                with self.subTest(user_name):
                    loc_name = gen_string("alpha")
                    user = entities.User(
                        login=user_name, firstname=user_name, lastname=user_name, password=gen_string("alpha")
                    ).create()
                    self.assertEqual(user.login, user_name)
                    set_context(session, org=ANY_CONTEXT["org"])
                    make_loc(session, name=loc_name, users=[user_name])
                    self.location.search(loc_name).click()
                    session.nav.click(tab_locators["context.tab_users"])
                    element = session.nav.wait_until_element((strategy1, value1 % user_name))
                    # Item is listed in 'Selected Items' list and not
                    # 'All Items' list.
                    self.assertIsNotNone(element)
                    self.location.update(loc_name, users=[user_name])
                    self.location.search(loc_name).click()
                    session.nav.click(tab_locators["context.tab_users"])
                    element = session.nav.wait_until_element((strategy, value % user_name))
                    # Item is listed in 'All Items' list and not
                    # 'Selected Items' list.
                    self.assertIsNotNone(element)
Beispiel #17
0
    def test_positive_remove_medium(self):
        """Remove medium by using location name and medium name

        @feature: Locations

        @assert: medium is added then removed
        """
        strategy, value = common_locators["entity_select"]
        strategy1, value1 = common_locators["entity_deselect"]
        with Session(self.browser) as session:
            for medium_name in generate_strings_list():
                with self.subTest(medium_name):
                    loc_name = gen_string("alpha")
                    medium = entities.Media(
                        name=medium_name, path_=INSTALL_MEDIUM_URL % gen_string("alpha", 6), os_family="Redhat"
                    ).create()
                    self.assertEqual(medium.name, medium_name)
                    set_context(session, org=ANY_CONTEXT["org"])
                    make_loc(session, name=loc_name, medias=[medium_name])
                    self.location.search(loc_name).click()
                    session.nav.click(tab_locators["context.tab_media"])
                    element = session.nav.wait_until_element((strategy1, value1 % medium_name))
                    # Item is listed in 'Selected Items' list and not
                    # 'All Items' list.
                    self.assertIsNotNone(element)
                    self.location.update(loc_name, medias=[medium_name])
                    self.location.search(loc_name).click()
                    session.nav.click(tab_locators["context.tab_media"])
                    element = session.nav.wait_until_element((strategy, value % medium_name))
                    # Item is listed in 'All Items' list and not
                    # 'Selected Items' list.
                    self.assertIsNotNone(element)
Beispiel #18
0
    def test_positive_add_compresource(self):
        """Add compute resource using the location name and compute resource
        name

        :id: 1d24414a-666d-490d-89b9-cd0704684cdd

        :expectedresults: compute resource is added successfully

        :CaseLevel: Integration
        """
        strategy, value = common_locators['entity_deselect']
        with Session(self) as session:
            for resource_name in generate_strings_list():
                with self.subTest(resource_name):
                    loc_name = gen_string('alpha')
                    url = (LIBVIRT_RESOURCE_URL %
                           settings.compute_resources.libvirt_hostname)
                    resource = entities.LibvirtComputeResource(
                        name=resource_name, url=url).create()
                    self.assertEqual(resource.name, resource_name)
                    make_loc(session, name=loc_name)
                    self.assertIsNotNone(self.location.search(loc_name))
                    self.location.update(
                        loc_name, new_resources=[resource_name])
                    self.location.search_and_click(loc_name)
                    session.nav.click(tab_locators['context.tab_resources'])
                    element = session.nav.wait_until_element(
                        (strategy, value % resource_name))
                    self.assertIsNotNone(element)
Beispiel #19
0
    def test_remove_hostgroup_1(self, host_grp_name):
        """@test: Add a hostgroup and remove it by using the location
        name and hostgroup name

        @feature: Locations

        @assert: hostgroup is added to location then removed

        """
        strategy, value = common_locators["all_values_selection"]
        loc_name = gen_string("alpha", 8)
        host_grp = entities.HostGroup(name=host_grp_name).create_json()
        self.assertEqual(host_grp['name'], host_grp_name)
        with Session(self.browser) as session:
            set_context(session, org=ANY_CONTEXT['org'])
            make_loc(session, name=loc_name)
            self.location.search(loc_name).click()
            session.nav.wait_until_element(
                tab_locators["context.tab_hostgrps"]).click()
            element = session.nav.wait_until_element((strategy,
                                                      value % host_grp_name))
            # Item is listed in 'Selected Items' list and not 'All Items' list.
            self.assertIsNotNone(element)
            self.hostgroup.delete(host_grp_name, True)
            self.location.search(loc_name).click()
            session.nav.wait_until_element(
                tab_locators["context.tab_hostgrps"]).click()
            element = session.nav.wait_until_element((strategy,
                                                      value % host_grp_name))
            # Item is listed in 'All Items' list and not 'Selected Items' list.
            self.assertIsNone(element)
Beispiel #20
0
    def test_positive_update_with_all_users_setting_only(self):
        """Create location and do not add user to it. Check and uncheck
        'all users' setting. Verify that for both operation expected location
        is assigned to user

        :id: 6596962b-8fd0-4a82-bf54-fa6a31147311

        :expectedresults: Location entity is assigned to user after checkbox
            was enabled and then disabled afterwards

        :BZ: 1321543

        :CaseLevel: Integration
        """
        loc_name = gen_string('alpha')
        user = entities.User().create()
        with Session(self) as session:
            set_context(session, org=ANY_CONTEXT['org'])
            make_loc(session, name=loc_name)
            for value in [True, False]:
                self.location.search_and_click(loc_name)
                self.location.click(tab_locators['context.tab_users'])
                self.location.assign_value(
                    locators['location.all_users'], value)
                self.location.click(common_locators['submit'])
                self.user.search_and_click(user.login)
                self.user.click(tab_locators['tab_loc'])
                self.assertIsNotNone(self.user.wait_until_element(
                    common_locators['entity_deselect'] % loc_name))
Beispiel #21
0
    def test_positive_add_org(self):
        """Add a organization by using the location name

        :id: 27d56d64-6866-46b6-962d-1ac2a11ae136

        :expectedresults: organization is added to location

        :CaseLevel: Integration
        """
        strategy, value = common_locators['entity_deselect']
        with Session(self) as session:
            for org_name in generate_strings_list():
                with self.subTest(org_name):
                    loc_name = gen_string('alpha')
                    org = entities.Organization(name=org_name).create()
                    self.assertEqual(org.name, org_name)
                    make_loc(session, name=loc_name)
                    self.assertIsNotNone(self.location.search(loc_name))
                    self.location.update(
                        loc_name, new_organizations=[org_name])
                    self.location.search_and_click(loc_name)
                    session.nav.click(
                        tab_locators['context.tab_organizations'])
                    element = session.nav.wait_until_element(
                        (strategy, value % org_name))
                    self.assertIsNotNone(element)
Beispiel #22
0
    def test_positive_add_user(self):
        """Create user then add that user by using the location name

        :id: bf9b3fc2-6193-4edc-aaec-cd7b87f0804c

        :expectedresults: User is added to location

        :CaseLevel: Integration
        """
        strategy, value = common_locators['entity_deselect']
        with Session(self) as session:
            # User names does not accept html values
            for user_name in generate_strings_list(
                    length=10,
                    exclude_types=['html']):
                with self.subTest(user_name):
                    loc_name = gen_string('alpha')
                    password = gen_string('alpha')
                    user = entities.User(
                        login=user_name,
                        firstname=user_name,
                        lastname=user_name,
                        password=password,
                    ).create()
                    self.assertEqual(user.login, user_name)
                    make_loc(session, name=loc_name)
                    self.assertIsNotNone(self.location.search(loc_name))
                    self.location.update(loc_name, new_users=[user_name])
                    self.location.search_and_click(loc_name)
                    session.nav.click(tab_locators['context.tab_users'])
                    element = session.nav.wait_until_element(
                        (strategy, value % user_name))
                    self.assertIsNotNone(element)
Beispiel #23
0
    def test_positive_add_subnet(self):
        """Add a subnet by using location name and subnet name

        :id: fe70ffba-e594-48d5-b2c5-be93e827cc60

        :expectedresults: subnet is added

        :CaseLevel: Integration
        """
        strategy, value = common_locators['entity_deselect']
        with Session(self) as session:
            for subnet_name in generate_strings_list():
                with self.subTest(subnet_name):
                    loc_name = gen_string('alpha')
                    subnet = entities.Subnet(
                        name=subnet_name,
                        network=gen_ipaddr(ip3=True),
                        mask='255.255.255.0',
                    ).create()
                    self.assertEqual(subnet.name, subnet_name)
                    make_loc(session, name=loc_name)
                    self.assertIsNotNone(self.location.search(loc_name))
                    self.location.update(loc_name, new_subnets=[subnet_name])
                    self.location.search_and_click(loc_name)
                    session.nav.click(tab_locators['context.tab_subnets'])
                    element = session.nav.wait_until_element(
                        (strategy, value % subnet_name))
                    self.assertIsNotNone(element)
Beispiel #24
0
    def test_positive_remove_domain(self):
        """Add a domain to an location and remove it by location name
        and domain name

        @feature: Locations

        @assert: the domain is removed from the location
        """
        strategy, value = common_locators['entity_select']
        strategy1, value1 = common_locators['entity_deselect']
        with Session(self.browser) as session:
            for domain_name in generate_strings_list():
                with self.subTest(domain_name):
                    loc_name = gen_string('alpha')
                    domain = entities.Domain(name=domain_name).create()
                    self.assertEqual(domain.name, domain_name)
                    set_context(session, org=ANY_CONTEXT['org'])
                    make_loc(session, name=loc_name, domains=[domain_name])
                    self.location.search(loc_name).click()
                    session.nav.click(tab_locators['context.tab_domains'])
                    element = session.nav.wait_until_element(
                        (strategy1, value1 % domain_name))
                    # Item is listed in 'Selected Items' list and not
                    # 'All Items' list.
                    self.assertIsNotNone(element)
                    self.location.update(loc_name, domains=[domain_name])
                    self.location.search(loc_name).click()
                    session.nav.click(tab_locators['context.tab_domains'])
                    element = session.nav.wait_until_element(
                        (strategy, value % domain_name))
                    # Item is listed in 'All Items' list and not
                    # 'Selected Items' list.
                    self.assertIsNotNone(element)
Beispiel #25
0
    def test_remove_environment_1(self, env_name):
        """@test: Remove environment by using location name & evironment name

        @feature: Locations

        @assert: environment is removed from Location

        """
        strategy, value = common_locators["entity_select"]
        strategy1, value1 = common_locators["entity_deselect"]
        loc_name = gen_string("alpha", 8)
        env = entities.Environment(name=env_name).create_json()
        self.assertEqual(env['name'], env_name)
        with Session(self.browser) as session:
            set_context(session, org=ANY_CONTEXT['org'])
            make_loc(session, name=loc_name, envs=[env_name])
            self.location.search(loc_name).click()
            session.nav.wait_until_element(
                tab_locators["context.tab_env"]).click()
            element = session.nav.wait_until_element((strategy1,
                                                      value1 % env_name))
            # Item is listed in 'Selected Items' list and not 'All Items' list.
            self.assertIsNotNone(element)
            self.location.update(loc_name, envs=[env_name])
            self.location.search(loc_name).click()
            session.nav.wait_until_element(
                tab_locators["context.tab_env"]).click()
            element = session.nav.wait_until_element((strategy,
                                                      value % env_name))
            # Item is listed in 'All Items' list and not 'Selected Items' list.
            self.assertIsNotNone(element)
Beispiel #26
0
    def test_positive_add_medium(self):
        """Add medium by using the location name and medium name

        :id: 738c5ff1-ef09-466f-aaac-64f194cac78d

        :expectedresults: medium is added

        :CaseLevel: Integration
        """
        strategy, value = common_locators['entity_deselect']
        with Session(self) as session:
            for medium_name in generate_strings_list():
                with self.subTest(medium_name):
                    loc_name = gen_string('alpha')
                    medium = entities.Media(
                        name=medium_name,
                        path_=INSTALL_MEDIUM_URL % gen_string('alpha', 6),
                        os_family='Redhat',
                    ).create()
                    self.assertEqual(medium.name, medium_name)
                    make_loc(session, name=loc_name)
                    self.assertIsNotNone(self.location.search(loc_name))
                    self.location.update(loc_name, new_medias=[medium_name])
                    self.location.search_and_click(loc_name)
                    session.nav.click(tab_locators['context.tab_media'])
                    element = session.nav.wait_until_element(
                        (strategy, value % medium_name))
                    self.assertIsNotNone(element)
Beispiel #27
0
    def test_remove_domain_1(self, domain_name):
        """@test: Add a domain to an location and remove it by location
        name and domain name

        @feature: Locations

        @assert: the domain is removed from the location

        """

        strategy, value = common_locators["entity_select"]
        strategy1, value1 = common_locators["entity_deselect"]
        loc_name = gen_string("alpha", 8)
        domain = entities.Domain(name=domain_name).create_json()
        self.assertEqual(domain['name'], domain_name)
        with Session(self.browser) as session:
            set_context(session, org=ANY_CONTEXT['org'])
            make_loc(session, name=loc_name, domains=[domain_name])
            self.location.search(loc_name).click()
            session.nav.wait_until_element(
                tab_locators["context.tab_domains"]).click()
            element = session.nav.wait_until_element((strategy1,
                                                      value1 % domain_name))
            # Item is listed in 'Selected Items' list and not 'All Items' list.
            self.assertIsNotNone(element)
            self.location.update(loc_name, domains=[domain_name])
            self.location.search(loc_name).click()
            session.nav.wait_until_element(
                tab_locators["context.tab_domains"]).click()
            element = session.nav.wait_until_element((strategy,
                                                      value % domain_name))
            # Item is listed in 'All Items' list and not 'Selected Items' list.
            self.assertIsNotNone(element)
Beispiel #28
0
    def test_positive_add_template(self):
        """Add config template by using location name and config template name.

        :id: 8faf60d1-f4d6-4a58-a484-606a42957ce7

        :expectedresults: config template is added.

        :CaseLevel: Integration
        """
        strategy, value = common_locators['all_values_selection']
        with Session(self) as session:
            for template in generate_strings_list():
                with self.subTest(template):
                    loc_name = gen_string('alpha')
                    make_loc(session, name=loc_name)
                    self.assertIsNotNone(self.location.search(loc_name))
                    make_templates(
                        session,
                        name=template,
                        template_path=get_data_file(OS_TEMPLATE_DATA_FILE),
                        custom_really=True,
                        template_type='Provisioning template',
                    )
                    self.assertIsNotNone(self.template.search(template))
                    self.location.search_and_click(loc_name)
                    session.nav.click(tab_locators['context.tab_template'])
                    element = session.nav.wait_until_element(
                        (strategy, value % template))
                    self.assertIsNotNone(element)
Beispiel #29
0
    def test_add_compresource(self):
        """Add compute resource using the location name and
        compute resource name

        @feature: Locations

        @assert: compute resource is added successfully
        """
        strategy, value = common_locators['entity_deselect']
        with Session(self.browser) as session:
            for resource_name in generate_strings_list():
                with self.subTest(resource_name):
                    loc_name = gen_string('alpha')
                    url = LIBVIRT_RESOURCE_URL % settings.server.hostname
                    resource = entities.LibvirtComputeResource(
                        name=resource_name, url=url).create()
                    self.assertEqual(resource.name, resource_name)
                    make_loc(session, name=loc_name)
                    self.assertIsNotNone(self.location.search(loc_name))
                    self.location.update(loc_name,
                                         new_resources=[resource_name])
                    self.location.search(loc_name).click()
                    session.nav.click(tab_locators['context.tab_resources'])
                    element = session.nav.wait_until_element(
                        (strategy, value % resource_name))
                    self.assertIsNotNone(element)
Beispiel #30
0
    def test_add_subnet_1(self, subnet_name):
        """@test: Add a subnet by using location name and subnet name

        @feature: Locations

        @assert: subnet is added

        """
        strategy, value = common_locators["entity_deselect"]
        loc_name = gen_string("alpha", 8)
        subnet_network = gen_ipaddr(ip3=True)
        subnet_mask = "255.255.255.0"
        subnet = entities.Subnet(
            name=subnet_name,
            network=subnet_network,
            mask=subnet_mask
        ).create_json()
        self.assertEqual(subnet['name'], subnet_name)
        with Session(self.browser) as session:
            make_loc(session, name=loc_name)
            self.assertIsNotNone(self.location.search(loc_name))
            self.location.update(loc_name, new_subnets=[subnet_name])
            self.location.search(loc_name).click()
            session.nav.wait_until_element(
                tab_locators["context.tab_subnets"]).click()
            element = session.nav.wait_until_element((strategy,
                                                      value % subnet_name))
            self.assertIsNotNone(element)
Beispiel #31
0
    def test_positive_remove_compresource(self):
        """Remove compute resource by using the location name and
        compute resource name

        @feature: Locations

        @assert: compute resource is added then removed
        """
        strategy, value = common_locators["entity_select"]
        strategy1, value1 = common_locators["entity_deselect"]
        with Session(self.browser) as session:
            for resource_name in generate_strings_list():
                with self.subTest(resource_name):
                    loc_name = gen_string("alpha")
                    url = LIBVIRT_RESOURCE_URL % settings.server.hostname
                    resource = entities.LibvirtComputeResource(name=resource_name, url=url).create()
                    self.assertEqual(resource.name, resource_name)
                    set_context(session, org=ANY_CONTEXT["org"])
                    make_loc(session, name=loc_name, resources=[resource_name])
                    self.location.search(loc_name).click()
                    session.nav.click(tab_locators["context.tab_resources"])
                    element = self.location.wait_until_element((strategy1, value1 % resource_name))
                    # Item is listed in 'Selected Items' list and not
                    # 'All Items' list.
                    self.assertIsNotNone(element)
                    self.location.update(loc_name, resources=[resource_name])
                    self.location.search(loc_name).click()
                    session.nav.click(tab_locators["context.tab_resources"])
                    element = session.nav.wait_until_element((strategy, value % resource_name))
                    # Item is listed in 'All Items' list and not
                    # 'Selected Items' list.
                    self.assertIsNotNone(element)
Beispiel #32
0
    def test_add_user_1(self, user_name):
        """@test: Create user then add user
        by using the location name

        @feature: Locations

        @assert: User is added to location

        """
        strategy, value = common_locators["entity_deselect"]
        loc_name = gen_string("alpha", 8)
        password = gen_string("alpha", 8)
        user = entities.User(
            login=user_name,
            firstname=user_name,
            lastname=user_name,
            password=password).create_json()
        self.assertEqual(user['login'], user_name)
        with Session(self.browser) as session:
            make_loc(session, name=loc_name)
            self.assertIsNotNone(self.location.search(loc_name))
            self.location.update(loc_name, new_users=[user_name])
            self.location.search(loc_name).click()
            session.nav.wait_until_element(
                tab_locators["context.tab_users"]).click()
            element = session.nav.wait_until_element((strategy,
                                                      value % user_name))
            self.assertIsNotNone(element)
Beispiel #33
0
    def test_positive_add_template(self):
        """Add config template by using location name and config
        template name.

        @feature: Locations

        @assert: config template is added.
        """
        strategy, value = common_locators['all_values_selection']
        with Session(self.browser) as session:
            for template in generate_strings_list():
                with self.subTest(template):
                    loc_name = gen_string('alpha')
                    make_loc(session, name=loc_name)
                    self.assertIsNotNone(self.location.search(loc_name))
                    make_templates(
                        session,
                        name=template,
                        template_path=get_data_file(OS_TEMPLATE_DATA_FILE),
                        custom_really=True,
                        template_type='provision',
                    )
                    self.assertIsNotNone(self.template.search(template))
                    self.location.search(loc_name).click()
                    session.nav.click(tab_locators['context.tab_template'])
                    element = session.nav.wait_until_element(
                        (strategy, value % template))
                    self.assertIsNotNone(element)
Beispiel #34
0
    def test_add_computeresource_1(self, resource_name):
        """@test: Add compute resource using the location
        name and computeresource name

        @feature: Locations

        @assert: computeresource is added

        """
        strategy, value = common_locators["entity_deselect"]
        loc_name = gen_string("alpha", 8)
        libvirt_url = "qemu+tcp://%s:16509/system"
        url = (libvirt_url % conf.properties['main.server.hostname'])
        resource = entities.ComputeResource(
            name=resource_name,
            provider='Libvirt',
            url=url
        ).create_json()
        self.assertEqual(resource['name'], resource_name)
        with Session(self.browser) as session:
            make_loc(session, name=loc_name)
            self.assertIsNotNone(self.location.search(loc_name))
            self.location.update(loc_name, new_resources=[resource_name])
            self.location.search(loc_name).click()
            session.nav.wait_until_element(
                tab_locators["context.tab_resources"]).click()
            element = session.nav.wait_until_element((strategy,
                                                      value % resource_name))
            self.assertIsNotNone(element)
Beispiel #35
0
    def test_positive_remove_environment(self):
        """Remove environment by using location name & environment name

        @feature: Locations

        @assert: environment is removed from Location
        """
        strategy, value = common_locators['entity_select']
        strategy1, value1 = common_locators['entity_deselect']
        with Session(self.browser) as session:
            for env_name in valid_env_names():
                with self.subTest(env_name):
                    loc_name = gen_string('alpha')
                    env = entities.Environment(name=env_name).create()
                    self.assertEqual(env.name, env_name)
                    set_context(session, org=ANY_CONTEXT['org'])
                    make_loc(session, name=loc_name, envs=[env_name])
                    self.location.search(loc_name).click()
                    session.nav.click(tab_locators['context.tab_env'])
                    element = session.nav.wait_until_element(
                        (strategy1, value1 % env_name))
                    # Item is listed in 'Selected Items' list and not
                    # 'All Items' list.
                    self.assertIsNotNone(element)
                    self.location.update(loc_name, envs=[env_name])
                    self.location.search(loc_name).click()
                    session.nav.click(tab_locators['context.tab_env'])
                    element = session.nav.wait_until_element(
                        (strategy, value % env_name))
                    # Item is listed in 'All Items' list and not
                    # 'Selected Items' list.
                    self.assertIsNotNone(element)
Beispiel #36
0
    def test_add_medium_1(self, medium_name):
        """@test: Add medium by using the location name and medium name

        @feature: Locations

        @assert: medium is added

        """
        strategy, value = common_locators["entity_deselect"]
        loc_name = gen_string("alpha", 8)
        path = INSTALL_MEDIUM_URL % gen_string("alpha", 6)
        medium = entities.Media(
            name=medium_name,
            media_path=path,
            os_family='Redhat',
        ).create_json()
        self.assertEqual(medium['name'], medium_name)
        with Session(self.browser) as session:
            make_loc(session, name=loc_name)
            self.assertIsNotNone(self.location.search(loc_name))
            self.location.update(loc_name, new_medias=[medium_name])
            self.location.search(loc_name).click()
            session.nav.wait_until_element(
                tab_locators["context.tab_media"]).click()
            element = session.nav.wait_until_element((strategy,
                                                      value % medium_name))
            self.assertIsNotNone(element)
Beispiel #37
0
    def test_positive_add_medium(self):
        """Add medium by using the location name and medium name

        :id: 738c5ff1-ef09-466f-aaac-64f194cac78d

        :expectedresults: medium is added

        :CaseLevel: Integration
        """
        strategy, value = common_locators['entity_deselect']
        with Session(self.browser) as session:
            for medium_name in generate_strings_list():
                with self.subTest(medium_name):
                    loc_name = gen_string('alpha')
                    medium = entities.Media(
                        name=medium_name,
                        path_=INSTALL_MEDIUM_URL % gen_string('alpha', 6),
                        os_family='Redhat',
                    ).create()
                    self.assertEqual(medium.name, medium_name)
                    make_loc(session, name=loc_name)
                    self.assertIsNotNone(self.location.search(loc_name))
                    self.location.update(loc_name, new_medias=[medium_name])
                    self.location.search_and_click(loc_name)
                    session.nav.click(tab_locators['context.tab_media'])
                    element = session.nav.wait_until_element(
                        (strategy, value % medium_name))
                    self.assertIsNotNone(element)
Beispiel #38
0
    def test_remove_user(self, user_name):
        """@test: Create admin users then add user and remove it by using the
        location name

        @feature: Locations

        @assert: The user is added then removed from the location

        """
        strategy, value = common_locators['entity_select']
        strategy1, value1 = common_locators['entity_deselect']
        loc_name = gen_string('alpha')
        user = entities.User(
            login=user_name,
            firstname=user_name,
            lastname=user_name,
            password=gen_string('alpha'),
        ).create()
        self.assertEqual(user.login, user_name)
        with Session(self.browser) as session:
            set_context(session, org=ANY_CONTEXT['org'])
            make_loc(session, name=loc_name, users=[user_name])
            self.location.search(loc_name).click()
            session.nav.click(tab_locators['context.tab_users'])
            element = session.nav.wait_until_element(
                (strategy1, value1 % user_name))
            # Item is listed in 'Selected Items' list and not 'All Items' list.
            self.assertIsNotNone(element)
            self.location.update(loc_name, users=[user_name])
            self.location.search(loc_name).click()
            session.nav.click(tab_locators['context.tab_users'])
            element = session.nav.wait_until_element(
                (strategy, value % user_name))
            # Item is listed in 'All Items' list and not 'Selected Items' list.
            self.assertIsNotNone(element)
Beispiel #39
0
    def test_positive_add_medium(self):
        """Add medium by using the location name and medium name

        @feature: Locations

        @assert: medium is added
        """
        strategy, value = common_locators['entity_deselect']
        with Session(self.browser) as session:
            for medium_name in generate_strings_list():
                with self.subTest(medium_name):
                    loc_name = gen_string('alpha')
                    medium = entities.Media(
                        name=medium_name,
                        path_=INSTALL_MEDIUM_URL % gen_string('alpha', 6),
                        os_family='Redhat',
                    ).create()
                    self.assertEqual(medium.name, medium_name)
                    make_loc(session, name=loc_name)
                    self.assertIsNotNone(self.location.search(loc_name))
                    self.location.update(loc_name, new_medias=[medium_name])
                    self.location.search(loc_name).click()
                    session.nav.click(tab_locators['context.tab_media'])
                    element = session.nav.wait_until_element(
                        (strategy, value % medium_name))
                    self.assertIsNotNone(element)
Beispiel #40
0
    def test_positive_add_org(self):
        """Add a organization by using the location name

        :id: 27d56d64-6866-46b6-962d-1ac2a11ae136

        :expectedresults: organization is added to location

        :CaseLevel: Integration
        """
        strategy, value = common_locators['entity_deselect']
        with Session(self.browser) as session:
            for org_name in generate_strings_list():
                with self.subTest(org_name):
                    loc_name = gen_string('alpha')
                    org = entities.Organization(name=org_name).create()
                    self.assertEqual(org.name, org_name)
                    make_loc(session, name=loc_name)
                    self.assertIsNotNone(self.location.search(loc_name))
                    self.location.update(loc_name,
                                         new_organizations=[org_name])
                    self.location.search_and_click(loc_name)
                    session.nav.click(
                        tab_locators['context.tab_organizations'])
                    element = session.nav.wait_until_element(
                        (strategy, value % org_name))
                    self.assertIsNotNone(element)
Beispiel #41
0
    def test_positive_add_user(self):
        """Create user then add that user by using the location name

        @feature: Locations

        @assert: User is added to location
        """
        strategy, value = common_locators['entity_deselect']
        with Session(self.browser) as session:
            # User names does not accept html values
            for user_name in generate_strings_list(
                    length=10,
                    remove_str='html'):
                with self.subTest(user_name):
                    loc_name = gen_string('alpha')
                    password = gen_string('alpha')
                    user = entities.User(
                        login=user_name,
                        firstname=user_name,
                        lastname=user_name,
                        password=password,
                    ).create()
                    self.assertEqual(user.login, user_name)
                    make_loc(session, name=loc_name)
                    self.assertIsNotNone(self.location.search(loc_name))
                    self.location.update(loc_name, new_users=[user_name])
                    self.location.search(loc_name).click()
                    session.nav.click(tab_locators['context.tab_users'])
                    element = session.nav.wait_until_element(
                        (strategy, value % user_name))
                    self.assertIsNotNone(element)
Beispiel #42
0
    def test_add_compresource(self):
        """Add compute resource using the location name and
        compute resource name

        @feature: Locations

        @assert: compute resource is added successfully
        """
        strategy, value = common_locators['entity_deselect']
        with Session(self.browser) as session:
            for resource_name in generate_strings_list():
                with self.subTest(resource_name):
                    loc_name = gen_string('alpha')
                    url = LIBVIRT_RESOURCE_URL % settings.server.hostname
                    resource = entities.LibvirtComputeResource(
                        name=resource_name, url=url).create()
                    self.assertEqual(resource.name, resource_name)
                    make_loc(session, name=loc_name)
                    self.assertIsNotNone(self.location.search(loc_name))
                    self.location.update(
                        loc_name, new_resources=[resource_name])
                    self.location.search(loc_name).click()
                    session.nav.click(tab_locators['context.tab_resources'])
                    element = session.nav.wait_until_element(
                        (strategy, value % resource_name))
                    self.assertIsNotNone(element)
Beispiel #43
0
    def test_remove_medium_1(self, medium_name):
        """@test: Remove medium by using location name and medium name

        @feature: Locations

        @assert: medium is added then removed

        """
        strategy, value = common_locators["entity_select"]
        strategy1, value1 = common_locators["entity_deselect"]
        loc_name = gen_string("alpha", 8)
        path = INSTALL_MEDIUM_URL % gen_string("alpha", 6)
        medium = entities.Media(
            name=medium_name,
            media_path=path,
            os_family='Redhat',
        ).create()
        self.assertEqual(medium['name'], medium_name)
        with Session(self.browser) as session:
            make_loc(session, name=loc_name, medias=[medium_name])
            self.location.search(loc_name).click()
            session.nav.wait_until_element(
                tab_locators["context.tab_media"]).click()
            element = session.nav.wait_until_element(
                (strategy1, value1 % medium_name))
            # Item is listed in 'Selected Items' list and not 'All Items' list.
            self.assertIsNotNone(element)
            self.location.update(loc_name, medias=[medium_name])
            self.location.search(loc_name).click()
            session.nav.wait_until_element(
                tab_locators["context.tab_media"]).click()
            element = session.nav.wait_until_element(
                (strategy, value % medium_name))
            # Item is listed in 'All Items' list and not 'Selected Items' list.
            self.assertIsNotNone(element)
Beispiel #44
0
    def test_positive_add_subnet(self):
        """Add a subnet by using location name and subnet name

        @feature: Locations

        @assert: subnet is added
        """
        strategy, value = common_locators['entity_deselect']
        with Session(self.browser) as session:
            for subnet_name in generate_strings_list():
                with self.subTest(subnet_name):
                    loc_name = gen_string('alpha')
                    subnet = entities.Subnet(
                        name=subnet_name,
                        network=gen_ipaddr(ip3=True),
                        mask='255.255.255.0',
                    ).create()
                    self.assertEqual(subnet.name, subnet_name)
                    make_loc(session, name=loc_name)
                    self.assertIsNotNone(self.location.search(loc_name))
                    self.location.update(loc_name, new_subnets=[subnet_name])
                    self.location.search(loc_name).click()
                    session.nav.click(tab_locators['context.tab_subnets'])
                    element = session.nav.wait_until_element(
                        (strategy, value % subnet_name))
                    self.assertIsNotNone(element)
Beispiel #45
0
    def test_remove_hostgroup_1(self, host_grp_name):
        """@test: Add a hostgroup and remove it by using the location
        name and hostgroup name

        @feature: Locations

        @assert: hostgroup is added to location then removed

        """
        strategy, value = common_locators["all_values_selection"]
        loc_name = gen_string("alpha", 8)
        host_grp = entities.HostGroup(name=host_grp_name).create()
        self.assertEqual(host_grp['name'], host_grp_name)
        with Session(self.browser) as session:
            make_loc(session, name=loc_name)
            self.location.search(loc_name).click()
            session.nav.wait_until_element(
                tab_locators["context.tab_hostgrps"]).click()
            element = session.nav.wait_until_element(
                (strategy, value % host_grp_name))
            # Item is listed in 'Selected Items' list and not 'All Items' list.
            self.assertIsNotNone(element)
            self.hostgroup.delete(host_grp_name, True)
            self.location.search(loc_name).click()
            session.nav.wait_until_element(
                tab_locators["context.tab_hostgrps"]).click()
            element = session.nav.wait_until_element(
                (strategy, value % host_grp_name))
            # Item is listed in 'All Items' list and not 'Selected Items' list.
            self.assertIsNone(element)
Beispiel #46
0
    def test_remove_computeresource_1(self, resource_name):
        """@test: Remove computeresource by using the location
        name and computeresource name

        @feature: Locations

        @assert: computeresource is added then removed

        """
        strategy, value = common_locators["entity_select"]
        strategy1, value1 = common_locators["entity_deselect"]
        loc_name = gen_string("alpha", 8)
        libvirt_url = "qemu+tcp://%s:16509/system"
        url = (libvirt_url % conf.properties['main.server.hostname'])
        resource = entities.ComputeResource(name=resource_name,
                                            provider='Libvirt',
                                            url=url).create()
        self.assertEqual(resource['name'], resource_name)
        with Session(self.browser) as session:
            make_loc(session, name=loc_name, resources=[resource_name])
            self.location.search(loc_name).click()
            session.nav.wait_until_element(
                tab_locators["context.tab_resources"]).click()
            ele = self.location.wait_until_element(
                (strategy1, value1 % resource_name))
            # Item is listed in 'Selected Items' list and not 'All Items' list.
            self.assertIsNotNone(ele)
            self.location.update(loc_name, resources=[resource_name])
            self.location.search(loc_name).click()
            session.nav.wait_until_element(
                tab_locators["context.tab_resources"]).click()
            element = session.nav.wait_until_element(
                (strategy, value % resource_name))
            # Item is listed in 'All Items' list and not 'Selected Items' list.
            self.assertIsNotNone(element)
Beispiel #47
0
    def test_remove_domain_1(self, domain_name):
        """@test: Add a domain to an location and remove it by location
        name and domain name

        @feature: Locations

        @assert: the domain is removed from the location

        """

        strategy, value = common_locators["entity_select"]
        strategy1, value1 = common_locators["entity_deselect"]
        loc_name = gen_string("alpha", 8)
        domain = entities.Domain(name=domain_name).create()
        self.assertEqual(domain['name'], domain_name)
        with Session(self.browser) as session:
            make_loc(session, name=loc_name, domains=[domain_name])
            self.location.search(loc_name).click()
            session.nav.wait_until_element(
                tab_locators["context.tab_domains"]).click()
            element = session.nav.wait_until_element(
                (strategy1, value1 % domain_name))
            # Item is listed in 'Selected Items' list and not 'All Items' list.
            self.assertIsNotNone(element)
            self.location.update(loc_name, domains=[domain_name])
            self.location.search(loc_name).click()
            session.nav.wait_until_element(
                tab_locators["context.tab_domains"]).click()
            element = session.nav.wait_until_element(
                (strategy, value % domain_name))
            # Item is listed in 'All Items' list and not 'Selected Items' list.
            self.assertIsNotNone(element)
Beispiel #48
0
    def test_remove_user_1(self, user_name):
        """@test: Create admin users then add user and remove it
        by using the location name

        @feature: Locations

        @assert: The user is added then removed from the location

        """
        strategy, value = common_locators["entity_select"]
        strategy1, value1 = common_locators["entity_deselect"]
        loc_name = gen_string("alpha", 8)
        password = gen_string("alpha", 8)
        user = entities.User(login=user_name,
                             firstname=user_name,
                             lastname=user_name,
                             password=password).create()
        self.assertEqual(user['login'], user_name)
        with Session(self.browser) as session:
            make_loc(session, name=loc_name, users=[user_name])
            self.location.search(loc_name).click()
            session.nav.wait_until_element(
                tab_locators["context.tab_users"]).click()
            element = session.nav.wait_until_element(
                (strategy1, value1 % user_name))
            # Item is listed in 'Selected Items' list and not 'All Items' list.
            self.assertIsNotNone(element)
            self.location.update(loc_name, users=[user_name])
            self.location.search(loc_name).click()
            session.nav.wait_until_element(
                tab_locators["context.tab_users"]).click()
            element = session.nav.wait_until_element(
                (strategy, value % user_name))
            # Item is listed in 'All Items' list and not 'Selected Items' list.
            self.assertIsNotNone(element)
Beispiel #49
0
    def test_remove_environment_1(self, env_name):
        """@test: Remove environment by using location name & evironment name

        @feature: Locations

        @assert: environment is removed from Location

        """
        strategy, value = common_locators["entity_select"]
        strategy1, value1 = common_locators["entity_deselect"]
        loc_name = gen_string("alpha", 8)
        env = entities.Environment(name=env_name).create()
        self.assertEqual(env['name'], env_name)
        with Session(self.browser) as session:
            make_loc(session, name=loc_name, envs=[env_name])
            self.location.search(loc_name).click()
            session.nav.wait_until_element(
                tab_locators["context.tab_env"]).click()
            element = session.nav.wait_until_element(
                (strategy1, value1 % env_name))
            # Item is listed in 'Selected Items' list and not 'All Items' list.
            self.assertIsNotNone(element)
            self.location.update(loc_name, envs=[env_name])
            self.location.search(loc_name).click()
            session.nav.wait_until_element(
                tab_locators["context.tab_env"]).click()
            element = session.nav.wait_until_element(
                (strategy, value % env_name))
            # Item is listed in 'All Items' list and not 'Selected Items' list.
            self.assertIsNotNone(element)
Beispiel #50
0
    def test_remove_subnet_1(self, subnet_name):
        """@test: Remove subnet by using location name and subnet name

        @feature: Locations

        @assert: subnet is added then removed

        """
        strategy, value = common_locators["entity_select"]
        strategy1, value1 = common_locators["entity_deselect"]
        loc_name = gen_string("alpha", 8)
        subnet_network = gen_ipaddr(ip3=True)
        subnet_mask = "255.255.255.0"
        subnet = entities.Subnet(name=subnet_name,
                                 network=subnet_network,
                                 mask=subnet_mask).create()
        self.assertEqual(subnet['name'], subnet_name)
        with Session(self.browser) as session:
            make_loc(session, name=loc_name, subnets=[subnet_name])
            self.location.search(loc_name).click()
            session.nav.wait_until_element(
                tab_locators["context.tab_subnets"]).click()
            element = session.nav.wait_until_element(
                (strategy1, value1 % subnet_name))
            # Item is listed in 'Selected Items' list and not 'All Items' list.
            self.assertIsNotNone(element)
            self.location.update(loc_name, subnets=[subnet_name])
            self.location.search(loc_name).click()
            self.location.wait_until_element(
                tab_locators["context.tab_subnets"]).click()
            element = session.nav.wait_until_element(
                (strategy, value % subnet_name))
            # Item is listed in 'All Items' list and not 'Selected Items' list.
            self.assertIsNotNone(element)
Beispiel #51
0
    def test_add_configtemplate_1(self, template):
        """@test: Add config template by using location name and
        configtemplate name.

        @feature: Locations

        @assert: configtemplate is added.

        """
        strategy, value = common_locators["all_values_selection"]
        loc_name = gen_string("alpha", 8)
        temp_type = 'provision'
        template_path = get_data_file(OS_TEMPLATE_DATA_FILE)
        with Session(self.browser) as session:
            make_loc(session, name=loc_name)
            self.assertIsNotNone(self.location.search(loc_name))
            make_templates(session,
                           name=template,
                           template_path=template_path,
                           custom_really=True,
                           template_type=temp_type)
            self.assertIsNotNone(self.template.search(template))
            self.location.search(loc_name).click()
            session.nav.wait_until_element(
                tab_locators["context.tab_template"]).click()
            element = session.nav.wait_until_element(
                (strategy, value % template))
            self.assertIsNotNone(element)
Beispiel #52
0
    def test_add_user_1(self, user_name):
        """@test: Create user then add user
        by using the location name

        @feature: Locations

        @assert: User is added to location

        """
        strategy, value = common_locators["entity_deselect"]
        loc_name = gen_string("alpha", 8)
        password = gen_string("alpha", 8)
        user = entities.User(login=user_name,
                             firstname=user_name,
                             lastname=user_name,
                             password=password).create()
        self.assertEqual(user['login'], user_name)
        with Session(self.browser) as session:
            make_loc(session, name=loc_name)
            self.assertIsNotNone(self.location.search(loc_name))
            self.location.update(loc_name, new_users=[user_name])
            self.location.search(loc_name).click()
            session.nav.wait_until_element(
                tab_locators["context.tab_users"]).click()
            element = session.nav.wait_until_element(
                (strategy, value % user_name))
            self.assertIsNotNone(element)
Beispiel #53
0
    def test_search_key_1(self, loc_name):
        """@test: Create location and search/find it

        @feature: Locations

        @assert: location can be found

        """
        with Session(self.browser) as session:
            make_loc(session, name=loc_name)
            self.assertIsNotNone(self.location.search(loc_name))
    def test_positive_add_foreman_role(self):
        """Associate foreman roles to User Group.
        [belonging to external AD User Group.]

        @id: c11fbf85-e144-4576-99e3-1ba111479f0f

        @Steps:

        1. Create an UserGroup.
        2. Assign some foreman roles to UserGroup.
        3. Create and associate an External AD UserGroup.

        @Assert: Whether a User belonging to User Group is able to access
        foreman entities as per roles.

        @CaseLevel: Integration
        """
        self.check_external_user()
        strategy, value = locators['login.loggedin']
        foreman_role = gen_string('alpha')
        location_name = gen_string('alpha')
        with Session(self.browser) as session:
            make_role(session, name=foreman_role)
            self.role.update(
                foreman_role,
                add_permission=True,
                permission_list=PERMISSIONS['Location'],
                resource_type='Location',
            )
            make_usergroup(
                session,
                name=self.usergroup_name,
                roles=[foreman_role],
                ext_usergrp='foobargroup',
                ext_authsourceid="LDAP-" + self.ldap_server_name,
            )
            self.assertIsNotNone(self.usergroup.search(self.usergroup_name))
            set_context(session, org=ANY_CONTEXT['org'])
            self.user.update(
                username=self.ldap_user_name,
                authorized_by='LDAP-' + self.ldap_server_name,
                new_password=self.ldap_user_passwd,
                password_confirmation=self.ldap_user_passwd,
            )
        with Session(
                self.browser,
                self.ldap_user_name,
                self.ldap_user_passwd,
        ) as session:
            self.assertIsNotNone(
                self.login.wait_until_element(
                    (strategy, value % self.ldap_user_name)))
            make_loc(session, name=location_name)
            self.assertIsNotNone(self.location.search(location_name))
Beispiel #55
0
    def test_positive_create_1(self, loc_name):
        """@test: Create Location with valid name only

        @feature: Locations

        @assert: Location is created, label is auto-generated

        """

        with Session(self.browser) as session:
            make_loc(session, name=loc_name)
            self.assertIsNotNone(self.location.search(loc_name))
Beispiel #56
0
    def test_positive_create_with_name(self):
        """Create Location with valid name only

        @feature: Locations

        @assert: Location is created, label is auto-generated
        """
        with Session(self.browser) as session:
            for loc_name in generate_strings_list():
                with self.subTest(loc_name):
                    make_loc(session, name=loc_name)
                    self.assertIsNotNone(self.location.search(loc_name))
Beispiel #57
0
    def test_positive_create_with_name(self):
        """Create Location with valid name only

        @id: 92b23082-09e4-49e1-92e1-d6d89d5180ac

        @assert: Location is created, label is auto-generated
        """
        with Session(self.browser) as session:
            for loc_name in generate_strings_list():
                with self.subTest(loc_name):
                    make_loc(session, name=loc_name)
                    self.assertIsNotNone(self.location.search(loc_name))
Beispiel #58
0
    def test_positive_create_with_name(self):
        """Create Location with valid name only

        :id: 92b23082-09e4-49e1-92e1-d6d89d5180ac

        :expectedresults: Location is created, label is auto-generated

        :CaseImportance: Critical
        """
        with Session(self) as session:
            for loc_name in generate_strings_list():
                with self.subTest(loc_name):
                    make_loc(session, name=loc_name)
                    self.assertIsNotNone(self.location.search(loc_name))
Beispiel #59
0
    def test_negative_create_with_invalid_names(self):
        """Create location with invalid name

        @id: 85f05458-b86c-4d94-a412-ea03412c4588

        @assert: location is not created
        """
        with Session(self.browser) as session:
            for loc_name in invalid_values_list(interface='ui'):
                with self.subTest(loc_name):
                    make_loc(session, name=loc_name)
                    error = session.nav.wait_until_element(
                        common_locators['name_haserror'])
                    self.assertIsNotNone(error)