Exemple #1
0
    def test_positive_update_2(self):
        """@Test: Check if Subnet network and mask can be updated

        @Feature: Subnet - Update

        @Assert: Subnet network and mask are updated

        """

        network = gen_ipaddr()
        mask = '255.255.255.0'
        try:
            subnet = make_subnet({
                u'network': network,
                u'mask': mask,
            })
        except CLIFactoryError as err:
            self.fail(err)
        new_network = gen_ipaddr()
        new_mask = '255.255.192.0'
        result = Subnet.update({
            u'id': subnet['id'],
            u'network': new_network,
            u'mask': new_mask,
        })
        self.assertEqual(result.return_code, 0)

        # check - subnet is updated
        result = Subnet.info({u'id': subnet['id']})
        self.assertEqual(result.stdout['network'], new_network)
        self.assertEqual(result.stdout['mask'], new_mask)
Exemple #2
0
    def test_positive_update_2(self):
        """@Test: Check if Subnet network and mask can be updated

        @Feature: Subnet - Update

        @Assert: Subnet network and mask are updated

        """

        network = gen_ipaddr()
        mask = '255.255.255.0'
        try:
            subnet = make_subnet({
                u'network': network,
                u'mask': mask,
            })
        except CLIFactoryError as err:
            self.fail(err)
        new_network = gen_ipaddr()
        new_mask = '255.255.192.0'
        result = Subnet.update({
            u'id': subnet['id'],
            u'network': new_network,
            u'mask': new_mask,
        })
        self.assertEqual(result.return_code, 0)

        # check - subnet is updated
        result = Subnet.info({u'id': subnet['id']})
        self.assertEqual(result.stdout['network'], new_network)
        self.assertEqual(result.stdout['mask'], new_mask)
Exemple #3
0
    def test_positive_update_network_mask(self):
        """Check if Subnet network and mask can be updated

        :id: 6a8d7750-71f1-4cd8-bf90-f2eac457c3b4

        :expectedresults: Subnet network and mask are updated

        :CaseImportance: Critical
        """
        network = gen_ipaddr()
        mask = '255.255.255.0'
        subnet = make_subnet({
            u'mask': mask,
            u'network': network,
        })
        new_network = gen_ipaddr()
        new_mask = '255.255.192.0'
        Subnet.update({
            u'id': subnet['id'],
            u'mask': new_mask,
            u'network': new_network,
        })
        # check - subnet is updated
        subnet = Subnet.info({u'id': subnet['id']})
        self.assertEqual(subnet['network-addr'], new_network)
        self.assertEqual(subnet['network-mask'], new_mask)
Exemple #4
0
    def test_positive_update_2(self):
        """@Test: Check if Subnet network and mask can be updated

        @Feature: Subnet - Update

        @Assert: Subnet network and mask are updated

        """
        network = gen_ipaddr()
        mask = '255.255.255.0'
        subnet = make_subnet({
            u'mask': mask,
            u'network': network,
        })
        new_network = gen_ipaddr()
        new_mask = '255.255.192.0'
        Subnet.update({
            u'id': subnet['id'],
            u'mask': new_mask,
            u'network': new_network,
        })
        # check - subnet is updated
        subnet = Subnet.info({u'id': subnet['id']})
        self.assertEqual(subnet['network'], new_network)
        self.assertEqual(subnet['mask'], new_mask)
    def test_positive_update_network_mask(self):
        """Check if Subnet network and mask can be updated

        :id: 6a8d7750-71f1-4cd8-bf90-f2eac457c3b4

        :expectedresults: Subnet network and mask are updated

        :CaseImportance: Critical
        """
        network = gen_ipaddr()
        mask = '255.255.255.0'
        subnet = make_subnet({
            u'mask': mask,
            u'network': network,
        })
        new_network = gen_ipaddr()
        new_mask = '255.255.192.0'
        Subnet.update({
            u'id': subnet['id'],
            u'mask': new_mask,
            u'network': new_network,
        })
        # check - subnet is updated
        subnet = Subnet.info({u'id': subnet['id']})
        self.assertEqual(subnet['network'], new_network)
        self.assertEqual(subnet['mask'], new_mask)
    def test_gen_ipv4_12(self):
        """
        @Test: Generate a 3 group IPv4 address with prefix too long
        @Feature: IPAddr Generator
        @Assert: An exception is raised
        """

        with self.assertRaises(ValueError):
            gen_ipaddr(ip3=True, ipv6=False, prefix=[10, 10, 10, 10])
    def test_gen_ipv4_12(self):
        """
        @Test: Generate a 3 group IPv4 address with prefix too long
        @Feature: IPAddr Generator
        @Assert: An exception is raised
        """

        with self.assertRaises(ValueError):
            gen_ipaddr(ip3=True, ipv6=False, prefix=[10, 10, 10, 10])
    def test_gen_ipv4_8(self):
        """
        @Test: Generate a 4 group IPv4 address with prefix disabling randomness
        @Feature: IPAddr Generator
        @Assert: An exception is raised
        """

        with self.assertRaises(ValueError):
            gen_ipaddr(ip3=False, ipv6=False, prefix=[10, 10, 10, 10])
    def test_gen_ipv4_8(self):
        """
        @Test: Generate a 4 group IPv4 address with prefix disabling randomness
        @Feature: IPAddr Generator
        @Assert: An exception is raised
        """

        with self.assertRaises(ValueError):
            gen_ipaddr(ip3=False, ipv6=False, prefix=[10, 10, 10, 10])
    def test_gen_ipv6_6(self):
        """
        @Test: Generate a IPv6 address with even longer prefix
        @Feature: IPAddr Generator
        @Assert: ValueError raised
        """

        prefix = 9 * ["e2d3"]
        with self.assertRaises(ValueError):
            gen_ipaddr(ipv6=True, prefix=prefix)
    def test_gen_ipv6_6(self):
        """
        @Test: Generate a IPv6 address with even longer prefix
        @Feature: IPAddr Generator
        @Assert: ValueError raised
        """

        prefix = 9 * ["e2d3"]
        with self.assertRaises(ValueError):
            gen_ipaddr(ipv6=True, prefix=prefix)
Exemple #12
0
    def test_positive_update_ip(self):
        """Update a host with a new IP address

        @feature: Hosts

        @assert: A host is updated with a new IP address
        """
        host = entities.Host(ip=gen_ipaddr()).create()
        new_ip = gen_ipaddr()
        host.ip = new_ip
        host = host.update(['ip'])
        self.assertEqual(host.ip, new_ip)
Exemple #13
0
    def test_positive_update_ip(self):
        """Update a host with a new IP address

        @id: 4c009db9-d720-429e-8150-bebf246d3a43

        @assert: A host is updated with a new IP address
        """
        host = entities.Host(ip=gen_ipaddr()).create()
        new_ip = gen_ipaddr()
        host.ip = new_ip
        host = host.update(['ip'])
        self.assertEqual(host.ip, new_ip)
Exemple #14
0
    def test_positive_update_ip(self):
        """Update a host with a new IP address

        @id: 4c009db9-d720-429e-8150-bebf246d3a43

        @assert: A host is updated with a new IP address
        """
        host = entities.Host(ip=gen_ipaddr()).create()
        new_ip = gen_ipaddr()
        host.ip = new_ip
        host = host.update(['ip'])
        self.assertEqual(host.ip, new_ip)
Exemple #15
0
    def test_positive_sort_by_network(self):
        """Create some Subnet entities and sort them by network address

        :id: 63dc846e-7520-4e8c-8875-a0109d7e5df4

        :customerscenario: true

        :expectedresults: Subnet entities are sorted by network address

        :BZ: 1268085, 1494180

        :CaseImportance: Medium
        """
        organization = entities.Organization().create()
        network_list = [gen_ipaddr(ip3=True) for _ in range(5)]
        network_list.sort(key=lambda s: map(int, s.split('.')), reverse=True)
        with Session(self) as session:
            set_context(session, org=organization.name)
            for ip in network_list:
                make_subnet(
                    session,
                    subnet_name=gen_string('alpha'),
                    subnet_network=ip,
                    subnet_mask=gen_netmask(),
                )
            sorted_list_asc = self.subnet.sort_table_by_column(
                'Network address')
            self.assertEqual([el.split('/', 1)[0] for el in sorted_list_asc],
                             network_list[::-1])
            sorted_list_desc = self.subnet.sort_table_by_column(
                'Network address')
            self.assertEqual([el.split('/', 1)[0] for el in sorted_list_desc],
                             network_list)
Exemple #16
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)
    def test_positive_add_subnet(self):
        """Add a subnet using organization name and subnet name.

        @id: 6736cd82-a2b0-4fc0-a2bc-99c9f13464d7

        @assert: 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):
                    org_name = gen_string('alpha')
                    # Create subnet using nailgun
                    subnet = entities.Subnet(
                        name=subnet_name,
                        network=gen_ipaddr(ip3=True),
                        mask='255.255.255.0'
                    ).create()
                    self.assertEqual(subnet.name, subnet_name)
                    make_org(session, org_name=org_name)
                    self.assertIsNotNone(self.org.search(org_name))
                    self.org.update(org_name, new_subnets=[subnet_name])
                    self.org.search(org_name).click()
                    session.nav.click(tab_locators['context.tab_subnets'])
                    element = session.nav.wait_until_element(
                        (strategy, value % subnet_name))
                    self.assertIsNotNone(element)
Exemple #18
0
    def test_positive_add_domain(self):
        """Create new subnet and associate domain with it

        :id: adbc7189-b451-49df-aa10-2ae732832dfe

        :expectedresults: Subnet is created with domain associated

        :CaseLevel: Integration
        """
        name = gen_string('alpha')
        domain = entities.Domain(
            organization=[self.organization]
        ).create()
        with Session(self) as session:
            make_subnet(
                session,
                org=self.organization.name,
                subnet_name=name,
                subnet_network=gen_ipaddr(ip3=True),
                subnet_mask=gen_netmask(),
                domains=[domain.name],
            )
            self.subnet.search_and_click(name)
            self.subnet.click(tab_locators['subnet.tab_domain'])
            element = self.subnet.wait_until_element(
                common_locators['entity_deselect'] % domain.name)
            checkbox_element = self.subnet.wait_until_element(
                common_locators['entity_checkbox'] % domain.name)
            # Depending upon the number of domains either, checkbox or
            # selection list appears.
            if element is None and checkbox_element is None:
                raise UIError('Neither checkbox or select list is present')
            if checkbox_element:
                self.assertTrue(checkbox_element.is_selected())
Exemple #19
0
    def test_positive_sort_by_network(self):
        """Create some Subnet entities and sort them by network address

        :id: 63dc846e-7520-4e8c-8875-a0109d7e5df4

        :expectedresults: Subnet entities are sorted by network address

        :BZ: 1268085, 1494180

        :CaseImportance: Medium
        """
        organization = entities.Organization().create()
        network_list = [gen_ipaddr(ip3=True) for _ in range(5)]
        network_list.sort(key=lambda s: map(int, s.split('.')), reverse=True)
        with Session(self) as session:
            set_context(session, org=organization.name)
            for ip in network_list:
                make_subnet(
                    session,
                    subnet_name=gen_string('alpha'),
                    subnet_network=ip,
                    subnet_mask=gen_netmask(),
                )
            sorted_list_asc = self.subnet.sort_table_by_column(
                'Network address')
            self.assertEqual(
                [el.split('/', 1)[0] for el in sorted_list_asc],
                network_list[::-1]
            )
            sorted_list_desc = self.subnet.sort_table_by_column(
                'Network address')
            self.assertEqual(
                [el.split('/', 1)[0] for el in sorted_list_desc],
                network_list
            )
def test_control_crud_ansible_playbook_action(request, catalog_item, action_collection):
    """
    Polarion:
        assignee: mmojzis
        casecomponent: Control
        initialEstimate: 1/12h
    """
    action = action_collection.create(
        fauxfactory.gen_alphanumeric(),
        action_type="Run Ansible Playbook",
        action_values={
            "run_ansible_playbook":
            {
                "playbook_catalog_item": catalog_item.name,
                "inventory": {
                    "target_machine": True
                }
            }
        }
    )
    request.addfinalizer(action.delete_if_exists)
    with update(action):
        ipaddr = fauxfactory.gen_ipaddr()
        new_descr = "edited_{}".format(fauxfactory.gen_alphanumeric())
        action.description = new_descr
        action.run_ansible_playbook = {
            "inventory": {
                "specific_hosts": True,
                "hosts": ipaddr
            }
        }
    view = navigate_to(action, "Edit")
    assert view.description.value == new_descr
    assert view.run_ansible_playbook.inventory.hosts.value == ipaddr
    action.delete()
Exemple #21
0
    def test_remove_subnet(self, subnet_name):
        """@test: Remove subnet by using organization name and subnet name.

        @feature: Organizations dis-associate subnet.

        @assert: subnet is added then removed.

        """
        strategy, value = common_locators['entity_select']
        strategy1, value1 = common_locators['entity_deselect']
        org_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)
        with Session(self.browser) as session:
            make_org(session, org_name=org_name, subnets=[subnet_name])
            self.org.search(org_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.org.update(org_name, subnets=[subnet_name])
            self.org.search(org_name).click()
            session.nav.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)
Exemple #22
0
    def test_remove_subnet(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')
        subnet = entities.Subnet(
            name=subnet_name,
            network=gen_ipaddr(ip3=True),
            mask='255.255.255.0',
        ).create()
        self.assertEqual(subnet.name, subnet_name)
        with Session(self.browser) as session:
            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)
Exemple #23
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()
        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)
Exemple #24
0
def test_positive_update_subnet(session):
    """Add/Remove subnet from/to location

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

    :expectedresults: subnet is added and removed from the location

    :CaseLevel: Integration
    """
    ip_addres = gen_ipaddr(ip3=True)
    subnet = entities.Subnet(
        network=ip_addres,
        mask='255.255.255.0',
    ).create()
    loc = entities.Location().create()
    with session:
        subnet_name = '{0} ({1}/{2})'.format(subnet.name, subnet.network,
                                             subnet.cidr)
        session.location.update(loc.name,
                                {'subnets.resources.assigned': [subnet_name]})
        loc_values = session.location.read(loc.name)
        assert loc_values['subnets']['resources']['assigned'][0] == subnet_name
        session.location.update(
            loc.name, {'subnets.resources.unassigned': [subnet_name]})
        loc_values = session.location.read(loc.name)
        assert len(loc_values['subnets']['resources']['assigned']) == 0
        assert subnet_name in loc_values['subnets']['resources']['unassigned']
Exemple #25
0
    def test_positive_add_domain(self):
        """Create new subnet and associate domain with it

        :id: adbc7189-b451-49df-aa10-2ae732832dfe

        :expectedresults: Subnet is created with domain associated

        :CaseLevel: Integration
        """
        name = gen_string('alpha')
        domain = entities.Domain(
            organization=[self.organization]
        ).create()
        with Session(self.browser) as session:
            make_subnet(
                session,
                org=self.organization.name,
                subnet_name=name,
                subnet_network=gen_ipaddr(ip3=True),
                subnet_mask=gen_netmask(),
                domains=[domain.name],
            )
            self.subnet.search_and_click(name)
            self.subnet.click(tab_locators['subnet.tab_domain'])
            element = self.subnet.wait_until_element(
                common_locators['entity_deselect'] % domain.name)
            checkbox_element = self.subnet.wait_until_element(
                common_locators['entity_checkbox'] % domain.name)
            # Depending upon the number of domains either, checkbox or
            # selection list appears.
            if element is None and checkbox_element is None:
                raise UIError('Neither checkbox or select list is present')
            if checkbox_element:
                self.assertTrue(checkbox_element.is_selected())
    def test_positive_create_with_address_pool(self):
        """Create subnet with valid address pool

        :id: d74a52a7-df56-44ef-89a3-081c14e81e43

        :expectedresults: Subnet is created and address pool is set

        :CaseImportance: Critical
        """
        for pool in valid_addr_pools():
            with self.subTest(pool):
                pool.sort()
                mask = '255.255.255.0'
                # generate pool range from network address
                network = gen_ipaddr()
                from_ip = re.sub(r'\d+$', str(pool[0]), network)
                to_ip = re.sub(r'\d+$', str(pool[1]), network)
                subnet = make_subnet({
                    u'from': from_ip,
                    u'mask': mask,
                    u'network': network,
                    u'to': to_ip,
                })
                self.assertEqual(subnet['from'], from_ip)
                self.assertEqual(subnet['to'], to_ip)
Exemple #27
0
    def test_positive_sort_by_name(self):
        """Create some Subnet entities and sort them by name

        :id: 0b07341c-717e-46a9-86cc-7192f3d8d449

        :customerscenario: true

        :expectedresults: Subnet entities are sorted by name

        :BZ: 1268085

        :CaseImportance: Medium
        """
        organization = entities.Organization().create()
        name_list = [gen_string('alpha', 20) for _ in range(5)]
        with Session(self) as session:
            set_context(session, org=organization.name)
            for name in name_list:
                make_subnet(
                    session,
                    subnet_name=name,
                    subnet_network=gen_ipaddr(ip3=True),
                    subnet_mask=gen_netmask(),
                )
            self.assertEqual(self.subnet.sort_table_by_column('Name'),
                             sorted(name_list, key=six.text_type.lower))
            self.assertEqual(
                self.subnet.sort_table_by_column('Name'),
                sorted(name_list, key=six.text_type.lower, reverse=True))
    def test_positive_add_subnet(self):
        """Add a subnet using organization name and subnet name.

        @feature: Organizations associate subnet.

        @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):
                    org_name = gen_string('alpha')
                    # Create subnet using nailgun
                    subnet = entities.Subnet(name=subnet_name,
                                             network=gen_ipaddr(ip3=True),
                                             mask='255.255.255.0').create()
                    self.assertEqual(subnet.name, subnet_name)
                    make_org(session, org_name=org_name)
                    self.assertIsNotNone(self.org.search(org_name))
                    self.org.update(org_name, new_subnets=[subnet_name])
                    self.org.search(org_name).click()
                    session.nav.click(tab_locators['context.tab_subnets'])
                    element = session.nav.wait_until_element(
                        (strategy, value % subnet_name))
                    self.assertIsNotNone(element)
Exemple #29
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)
Exemple #30
0
    def test_positive_add_domain(self):
        """Create new subnet and associate domain with it

        @Feature: Subnet - Positive Create

        @Assert: Subnet is created with domain associated
        """
        strategy1, value1 = common_locators['entity_deselect']
        strategy2, value2 = common_locators['entity_checkbox']
        name = gen_string('alpha')
        domain = entities.Domain(
            organization=[self.organization]
        ).create()
        with Session(self.browser) as session:
            make_subnet(
                session,
                org=self.organization.name,
                subnet_name=name,
                subnet_network=gen_ipaddr(ip3=True),
                subnet_mask=gen_netmask(),
                domains=[domain.name],
            )
            subnet = self.subnet.search(name)
            session.nav.click(subnet)
            session.nav.click(tab_locators['subnet.tab_domain'])
            element = session.nav.wait_until_element(
                (strategy1, value1 % domain.name))
            checkbox_element = session.nav.wait_until_element(
                (strategy2, value2 % domain.name))
            # Depending upon the number of domains either, checkbox or
            # selection list appears.
            if element is None and checkbox_element is None:
                raise UIError('Neither checkbox or select list is present')
            if checkbox_element:
                self.assertTrue(checkbox_element.is_selected())
Exemple #31
0
    def test_create_subnet_3(self):
        """@Test: Create new subnet and associate domain with it

        @Feature: Subnet - Positive Create

        @Assert: Subnet is created with domain associated

        """
        strategy1, value1 = common_locators["entity_deselect"]
        strategy2, value2 = common_locators["entity_checkbox"]
        name = gen_string("alpha", 4)
        network = gen_ipaddr(ip3=True)
        mask = gen_netmask()
        domain_name = entities.Domain().create()['name']
        with Session(self.browser) as session:
            make_subnet(session, subnet_name=name, subnet_network=network,
                        subnet_mask=mask, domains=[domain_name])
            self.assertIsNotNone(self.subnet.search_subnet(subnet_name=name))
            session.nav.search_entity(
                name, locators['subnet.display_name']).click()
            session.nav.wait_until_element(
                tab_locators["subnet.tab_domain"]).click()
            element = session.nav.wait_until_element(
                (strategy1, value1 % domain_name))
            checkbox_element = session.nav.wait_until_element(
                (strategy2, value2 % domain_name))
            # Depending upon the number of domains either, checkbox or
            # selection list appears.
            if element:
                self.assertIsNotNone(element)
            elif checkbox_element:
                self.assertTrue(checkbox_element.is_selected())
            else:
                self.assertIsNotNone()
Exemple #32
0
    def test_positive_sort_by_name(self):
        """Create some Subnet entities and sort them by name

        :id: 0b07341c-717e-46a9-86cc-7192f3d8d449

        :expectedresults: Subnet entities are sorted by name

        :BZ: 1268085

        :CaseImportance: Medium
        """
        organization = entities.Organization().create()
        name_list = [gen_string('alpha', 20) for _ in range(5)]
        with Session(self) as session:
            set_context(session, org=organization.name)
            for name in name_list:
                make_subnet(
                    session,
                    subnet_name=name,
                    subnet_network=gen_ipaddr(ip3=True),
                    subnet_mask=gen_netmask(),
                )
            self.assertEqual(
                self.subnet.sort_table_by_column('Name'),
                sorted(name_list, key=six.text_type.lower)
            )
            self.assertEqual(
                self.subnet.sort_table_by_column('Name'),
                sorted(name_list, key=six.text_type.lower, reverse=True)
            )
Exemple #33
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)
Exemple #34
0
    def test_remove_subnet_1(self, subnet_name):
        """@test: Remove subnet by using organization name and subnet name.

        @feature: Organizations dis-associate subnet.

        @assert: subnet is added then removed.

        """
        strategy, value = common_locators["entity_select"]
        strategy1, value1 = common_locators["entity_deselect"]
        org_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_org(session, org_name=org_name, subnets=[subnet_name])
            self.org.search(org_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.org.update(org_name, subnets=[subnet_name])
            self.org.search(org_name).click()
            session.nav.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)
Exemple #35
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)
Exemple #36
0
def test_control_crud_ansible_playbook_action(request, catalog_item,
                                              action_collection):
    action = action_collection.create(fauxfactory.gen_alphanumeric(),
                                      action_type="Run Ansible Playbook",
                                      action_values={
                                          "run_ansible_playbook": {
                                              "playbook_catalog_item":
                                              catalog_item.name,
                                              "inventory": {
                                                  "target_machine": True
                                              }
                                          }
                                      })
    request.addfinalizer(action.delete_if_exists)
    with update(action):
        ipaddr = fauxfactory.gen_ipaddr()
        new_descr = "edited_{}".format(fauxfactory.gen_alphanumeric())
        action.description = new_descr
        action.run_ansible_playbook = {
            "inventory": {
                "specific_hosts": True,
                "hosts": ipaddr
            }
        }
    view = navigate_to(action, "Edit")
    assert view.description.value == new_descr
    assert view.run_ansible_playbook.inventory.hosts.value == ipaddr
    action.delete()
Exemple #37
0
    def test_add_subnet_1(self, subnet_name):
        """@test: Add a subnet by using organization name and subnet name.

        @feature: Organizations associate subnet.

        @assert: subnet is added.

        """
        strategy, value = common_locators["entity_deselect"]
        org_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_org(session, org_name=org_name)
            self.assertIsNotNone(self.org.search(org_name))
            self.org.update(org_name, new_subnets=[subnet_name])
            self.org.search(org_name).click()
            self.org.wait_until_element(
                tab_locators["context.tab_subnets"]).click()
            element = session.nav.wait_until_element((strategy,
                                                      value % subnet_name))
            self.assertIsNotNone(element)
Exemple #38
0
def create_discovered_host(name=None,
                           ip_address=None,
                           mac_address=None,
                           options=None):
    """Creates a discovered host.

    :param str name: Name of discovered host.
    :param str ip_address: A valid ip address.
    :param str mac_address: A valid mac address.
    :param dict options: additional facts to add to discovered host
    :return: dict of ``entities.DiscoveredHost`` facts.
    """
    if name is None:
        name = gen_string('alpha')
    if ip_address is None:
        ip_address = gen_ipaddr()
    if mac_address is None:
        mac_address = gen_mac(multicast=False)
    if options is None:
        options = {}
    facts = {
        'name': name,
        'discovery_bootip': ip_address,
        'discovery_bootif': mac_address,
        'interfaces': 'eth0',
        'ipaddress': ip_address,
        'ipaddress_eth0': ip_address,
        'macaddress': mac_address,
        'macaddress_eth0': mac_address,
    }
    facts.update(options)
    return entities.DiscoveredHost().facts(json={'facts': facts})
    def test_positive_remove_subnet(self):
        """Remove subnet by using organization name and subnet name.

        @feature: Organizations dis-associate subnet.

        @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):
                    org_name = gen_string("alpha")
                    # Create subnet using nailgun
                    subnet = entities.Subnet(
                        name=subnet_name, network=gen_ipaddr(ip3=True), mask="255.255.255.0"
                    ).create()
                    self.assertEqual(subnet.name, subnet_name)
                    make_org(session, org_name=org_name, subnets=[subnet_name])
                    self.org.search(org_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.org.update(org_name, subnets=[subnet_name])
                    self.org.search(org_name).click()
                    session.nav.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)
Exemple #40
0
def generate_system_facts(name=None):
    """Generate random system facts for registration.

    :param str name: A valid FQDN for a system. If one is not
        provided, then a random value will be generated.
    :return: A dictionary with random system facts
    :rtype: dict
    """
    if name is None:
        name = f'{gen_alpha().lower()}.example.net'

    # Make a copy of the system facts 'template'
    new_facts = copy.deepcopy(SYSTEM_FACTS)
    # Select a random RHEL version...
    distro = gen_choice(DISTRO_IDS)

    # ...and update our facts
    new_facts['distribution.id'] = distro['id']
    new_facts['distribution.version'] = distro['version']
    new_facts['dmi.bios.relase_date'] = _bios_date().strftime('%m/%d/%Y')
    new_facts['dmi.memory.maximum_capacity'] = gen_choice(MEMORY_CAPACITY)
    new_facts['dmi.memory.size'] = gen_choice(MEMORY_SIZE)
    new_facts['dmi.system.uuid'] = gen_uuid()
    new_facts['dmi.system.version'] = 'RHEL'
    new_facts['lscpu.architecture'] = distro['architecture']
    new_facts['net.interface.eth1.hwaddr'] = gen_mac(multicast=False)
    new_facts['net.interface.eth1.ipaddr'] = gen_ipaddr()
    new_facts['network.hostname'] = name
    new_facts['network.ipaddr'] = new_facts['net.interface.eth1.ipaddr']
    new_facts['uname.machine'] = distro['architecture']
    new_facts['uname.nodename'] = name
    new_facts['uname.release'] = distro['kernel']
    new_facts['virt.uuid'] = new_facts['dmi.system.uuid']

    return new_facts
Exemple #41
0
def test_positive_create_and_update_with_ip():
    """Create and update host with IP address specified

    :id: 3f266906-c509-42ce-9b20-def448bf8d86

    :expectedresults: A host is created and updated with static IP address

    :CaseImportance: Critical
    """
    ip_addr = gen_ipaddr()
    host = entities.Host(ip=ip_addr).create()
    assert host.ip == ip_addr
    new_ip_addr = gen_ipaddr()
    host.ip = new_ip_addr
    host = host.update(['ip'])
    assert host.ip == new_ip_addr
Exemple #42
0
    def test_positive_create_with_address_pool(self):
        """Create subnet with valid address pool

        :id: d74a52a7-df56-44ef-89a3-081c14e81e43

        :expectedresults: Subnet is created and address pool is set

        :CaseImportance: Critical
        """
        for pool in valid_addr_pools():
            with self.subTest(pool):
                pool.sort()
                mask = '255.255.255.0'
                # generate pool range from network address
                network = gen_ipaddr()
                from_ip = re.sub(r'\d+$', str(pool[0]), network)
                to_ip = re.sub(r'\d+$', str(pool[1]), network)
                subnet = make_subnet({
                    u'from': from_ip,
                    u'mask': mask,
                    u'network': network,
                    u'to': to_ip,
                })
                self.assertEqual(subnet['start-of-ip-range'], from_ip)
                self.assertEqual(subnet['end-of-ip-range'], to_ip)
def _create_discovered_host(name=None, ipaddress=None, macaddress=None):
    """Creates discovered host by uploading few fake facts.

    :param str name: Name of discovered host. If ``None`` then a random
        value will be generated.
    :param str ipaddress: A valid ip address.
        If ``None`` then then a random value will be generated.
    :param str macaddress: A valid mac address.
        If ``None`` then then a random value will be generated.
    :return: A ``dict`` of ``DiscoveredHost`` facts.
    """
    if name is None:
        name = gen_string('alpha')
    if ipaddress is None:
        ipaddress = gen_ipaddr()
    if macaddress is None:
        macaddress = gen_mac(multicast=False)
    return entities.DiscoveredHost().facts(json={
        u'facts': {
            u'name': name,
            u'discovery_bootip': ipaddress,
            u'discovery_bootif': macaddress,
            u'interfaces': 'eth0',
            u'ipaddress': ipaddress,
            u'macaddress': macaddress,
            u'macaddress_eth0': macaddress,
            u'ipaddress_eth0': ipaddress,
        }
    })
def test_positive_update_subnet(session):
    """Add/Remove subnet from/to location

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

    :expectedresults: subnet is added and removed from the location

    :CaseLevel: Integration
    """
    ip_addres = gen_ipaddr(ip3=True)
    subnet = entities.Subnet(
        network=ip_addres,
        mask='255.255.255.0',
    ).create()
    loc = entities.Location().create()
    with session:
        subnet_name = '{0} ({1}/{2})'.format(
            subnet.name, subnet.network, subnet.cidr)
        session.location.update(
            loc.name, {'subnets.resources.assigned': [subnet_name]})
        loc_values = session.location.read(loc.name)
        assert loc_values['subnets']['resources']['assigned'][0] == subnet_name
        session.location.update(
            loc.name, {'subnets.resources.unassigned': [subnet_name]})
        loc_values = session.location.read(loc.name)
        assert len(loc_values['subnets']['resources']['assigned']) == 0
        assert subnet_name in loc_values['subnets']['resources']['unassigned']
Exemple #45
0
    def setUp(self):
        requests_intercept.install()
        add_wsgi_intercept("httpbin.org", 80, self.get_app)

        logging.getLogger("requests").setLevel("ERROR")
        self.fake_target = fauxfactory.gen_ipaddr()
        self.service = HttpService(self.fake_target)
Exemple #46
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)
Exemple #47
0
def _create_discovered_host(name=None, ipaddress=None, macaddress=None):
    """Creates discovered host by uploading few fake facts.

    :param str name: Name of discovered host. If ``None`` then a random
        value will be generated.
    :param str ipaddress: A valid ip address.
        If ``None`` then then a random value will be generated.
    :param str macaddress: A valid mac address.
        If ``None`` then then a random value will be generated.
    :return: A ``dict`` of ``DiscoveredHost`` facts.
    """
    if name is None:
        name = gen_string('alpha')
    if ipaddress is None:
        ipaddress = gen_ipaddr()
    if macaddress is None:
        macaddress = gen_mac(multicast=False)
    return entities.DiscoveredHost().facts(
        json={
            u'facts': {
                u'name': name,
                u'discovery_bootip': ipaddress,
                u'discovery_bootif': macaddress,
                u'interfaces': 'eth0',
                u'ipaddress': ipaddress,
                u'macaddress': macaddress,
                u'macaddress_eth0': macaddress,
                u'ipaddress_eth0': ipaddress,
            }
        })
Exemple #48
0
def create_discovered_host(name=None, ip_address=None, mac_address=None,
                           options=None):
    """Creates a discovered host.

    :param str name: Name of discovered host.
    :param str ip_address: A valid ip address.
    :param str mac_address: A valid mac address.
    :param dict options: additional facts to add to discovered host
    :returns dict of ``entities.DiscoveredHost`` facts.
    """
    if name is None:
        name = gen_string('alpha')
    if ip_address is None:
        ip_address = gen_ipaddr()
    if mac_address is None:
        mac_address = gen_mac(multicast=False)
    if options is None:
        options = {}
    facts = {
            'name': name,
            'discovery_bootip': ip_address,
            'discovery_bootif': mac_address,
            'interfaces': 'eth0',
            'ipaddress': ip_address,
            'ipaddress_eth0': ip_address,
            'macaddress': mac_address,
            'macaddress_eth0': mac_address,
        }
    facts.update(options)
    return entities.DiscoveredHost().facts(json={'facts': facts})
Exemple #49
0
    def test_positive_add_domain(self):
        """Create new subnet and associate domain with it

        @Feature: Subnet - Positive Create

        @Assert: Subnet is created with domain associated
        """
        strategy1, value1 = common_locators['entity_deselect']
        strategy2, value2 = common_locators['entity_checkbox']
        name = gen_string('alpha')
        domain = entities.Domain(organization=[self.organization]).create()
        with Session(self.browser) as session:
            make_subnet(
                session,
                org=self.organization.name,
                subnet_name=name,
                subnet_network=gen_ipaddr(ip3=True),
                subnet_mask=gen_netmask(),
                domains=[domain.name],
            )
            subnet = self.subnet.search(name)
            session.nav.click(subnet)
            session.nav.click(tab_locators['subnet.tab_domain'])
            element = session.nav.wait_until_element(
                (strategy1, value1 % domain.name))
            checkbox_element = session.nav.wait_until_element(
                (strategy2, value2 % domain.name))
            # Depending upon the number of domains either, checkbox or
            # selection list appears.
            if element is None and checkbox_element is None:
                raise UIError('Neither checkbox or select list is present')
            if checkbox_element:
                self.assertTrue(checkbox_element.is_selected())
Exemple #50
0
    def test_update_subnet_2(self, name):
        """@Test: Update Subnet network

        @Feature: Subnet - Positive Update

        @Assert: Subnet network is updated

        """
        network = gen_ipaddr(ip3=True)
        mask = gen_netmask()
        new_network = gen_ipaddr(ip3=True)
        with Session(self.browser) as session:
            make_subnet(session, subnet_name=name, subnet_network=network,
                        subnet_mask=mask)
            self.subnet.update(name, new_subnet_network=new_network)
            result_object = self.subnet.search_subnet(name)
            self.assertEqual(new_network, result_object['network'])
Exemple #51
0
def test_ip_max_valid_character_validation(request):
    """Test to validate max character for ip address field with valid ip address"""
    prov = OpenStackProvider(name=fauxfactory.gen_alphanumeric(5),
                             hostname=fauxfactory.gen_alphanumeric(5),
                             ip_address=fauxfactory.gen_ipaddr(prefix=[10]))

    request.addfinalizer(prov.delete_if_exists)
    prov.create()
Exemple #52
0
    def test_positive_update_network_mask(self):
        """Check if Subnet network and mask can be updated

        @id: 6a8d7750-71f1-4cd8-bf90-f2eac457c3b4

        @Assert: Subnet network and mask are updated
        """
        network = gen_ipaddr()
        mask = "255.255.255.0"
        subnet = make_subnet({u"mask": mask, u"network": network})
        new_network = gen_ipaddr()
        new_mask = "255.255.192.0"
        Subnet.update({u"id": subnet["id"], u"mask": new_mask, u"network": new_network})
        # check - subnet is updated
        subnet = Subnet.info({u"id": subnet["id"]})
        self.assertEqual(subnet["network"], new_network)
        self.assertEqual(subnet["mask"], new_mask)
Exemple #53
0
def test_ip_max_valid_character_validation(request):
    """Test to validate max character for ip address field with valid ip address"""
    prov = OpenStackProvider(
        name=fauxfactory.gen_alphanumeric(5),
        hostname=fauxfactory.gen_alphanumeric(5),
        ip_address=fauxfactory.gen_ipaddr(prefix=[10]))

    request.addfinalizer(prov.delete_if_exists)
    prov.create()
Exemple #54
0
def test_api_port_blank_validation(request):
    """Test to validate blank api port while adding a provider"""
    prov = OpenStackProvider(name=fauxfactory.gen_alphanumeric(5),
                             hostname=fauxfactory.gen_alphanumeric(5),
                             ip_address=fauxfactory.gen_ipaddr(prefix=[10]),
                             api_port='')

    request.addfinalizer(prov.delete_if_exists)
    prov.create()
Exemple #55
0
def test_api_port_max_character_validation(request):
    """Test to validate max character for api port field"""
    prov = OpenStackProvider(name=fauxfactory.gen_alphanumeric(5),
                             hostname=fauxfactory.gen_alphanumeric(5),
                             ip_address=fauxfactory.gen_ipaddr(prefix=[10]),
                             api_port=fauxfactory.gen_alphanumeric(15))

    request.addfinalizer(prov.delete_if_exists)
    prov.create()
Exemple #56
0
def test_host_name_required_validation(request):
    """Test to validate the hostname while adding a provider"""
    prov = OpenStackProvider(name=fauxfactory.gen_alphanumeric(5),
                             hostname=None,
                             ip_address=fauxfactory.gen_ipaddr(prefix=[10]))

    request.addfinalizer(prov.delete_if_exists)
    with error.expected("Host Name can't be blank"):
        prov.create()
def test_host_name_required_validation(request):
    """Test to validate the hostname while adding a provider"""
    prov = OpenStackProvider(
        name=fauxfactory.gen_alphanumeric(5), hostname=None, ip_address=fauxfactory.gen_ipaddr(prefix=[10])
    )

    request.addfinalizer(prov.delete_if_exists)
    with error.expected("Host Name can't be blank"):
        prov.create()
Exemple #58
0
    def test_positive_create_with_ip(self):
        """Create a host with IP address specified

        @id: 3f266906-c509-42ce-9b20-def448bf8d86

        @assert: A host is created with expected IP address
        """
        ip_addr = gen_ipaddr()
        host = entities.Host(ip=ip_addr).create()
        self.assertEqual(host.ip, ip_addr)
    def test_gen_ipv6_2(self):
        """
        @Test: Generate a IPv6 address
        @Feature: IPAddr Generator
        @Assert: A IPv6 address is generated
        """

        result = gen_ipaddr(ip3=True, ipv6=True)
        self.assertTrue(
            len(result.split(":")) == 8, "Did not generate a IPv6 addrss")