def _create_subnet(self, network, cidr): user_enterprise = self.session.user.enterprises.get_first( filter='name == "{}"'.format(utils.get_vsd_net_parition_name())) # Create VSD managed subnet l3domain = utils.create_l3_domain(self, user_enterprise) zone = l3domain.create_child( vspk.NUZone(name=utils.get_random_name()))[0] subnet = zone.create_child( vspk.NUSubnet(name=utils.get_random_name(), address=str(cidr.ip), netmask=str(cidr.netmask)))[0] cmd_create = ('subnet create -f json --network {network} ' '--net-partition {net_partition} --nuagenet {nuagenet} ' '--subnet-range {subnet_range} {subnet_name}' .format(network=network, net_partition=user_enterprise.id, nuagenet=subnet.id, subnet_range=cidr, subnet_name=utils.get_random_name())) create_output = json.loads(self.openstack(cmd_create)) self.addCleanup(self.openstack, 'subnet delete {}'.format(create_output['id'])) return create_output, l3domain
def setUp(self): super(NuagePolicyGroupTests, self).setUp() network = self._create_network() self.subnet1, self.l3domain1 = self._create_subnet( network=network['id'], cidr=netaddr.IPNetwork('10.0.0.0/24')) self.subnet2, self.l3domain2 = self._create_subnet( network=network['id'], cidr=netaddr.IPNetwork('20.0.0.0/24')) self.nuage_pg1 = self._create_nuage_pg( self.l3domain1, name=utils.get_random_name(), type='SOFTWARE', description=utils.get_random_name(), evpn_community_tag='1:2', external=True) self.nuage_pg2 = self._create_nuage_pg( self.l3domain2, name=utils.get_random_name(), type='SOFTWARE', description=utils.get_random_name(), external=False) self.port1 = self._create_port(network_id=network['id'], subnet_id=self.subnet1['id']) self.port2 = self._create_port(network_id=network['id'], subnet_id=self.subnet2['id'])
def test_nuage_uplink_option(self): external_network_1_name = get_random_name() self.openstack('network create --external {}' .format(external_network_1_name)) self.addCleanup(self.openstack, 'network delete {}' .format(external_network_1_name)) external_network_2_name = get_random_name() self.openstack('network create --external {}' .format(external_network_2_name)) self.addCleanup(self.openstack, 'network delete {}' .format(external_network_2_name)) subnet_1_name = get_random_name() cmd = ('subnet create -f json --underlay False --network {network} ' '--subnet-range'.format(network=external_network_1_name)) cmd_output = self._subnet_create(cmd, subnet_1_name) self.addCleanup(self.openstack, ('subnet delete {}' .format(subnet_1_name))) nuage_uplink_1 = cmd_output['nuage_uplink'] self.assertIsNotNone(nuage_uplink_1) subnet_2_name = get_random_name() cmd = ('subnet create -f json --underlay False --network {network} ' '--nuage-uplink {uplink} ' '--subnet-range'.format(network=external_network_2_name, uplink=nuage_uplink_1)) cmd_output = self._subnet_create(cmd, subnet_2_name) self.addCleanup(self.openstack, ('subnet delete {}' .format(subnet_2_name))) nuage_uplink_2 = cmd_output['nuage_uplink'] self.assertEqual(nuage_uplink_1, nuage_uplink_2)
def setUp(self): super(NuagePortTestsVSDManaged, self).setUp() # Create VSD managed subnet user_enterprise = self.session.user.enterprises.get_first( filter='name == "{}"'.format(utils.get_vsd_net_parition_name())) self.l3domain = utils.create_l3_domain(self, user_enterprise) zone = self.l3domain.create_child( vspk.NUZone(name=utils.get_random_name()))[0] subnet = zone.create_child( vspk.NUSubnet(name=utils.get_random_name(), address='10.0.0.0', netmask='255.255.255.0'))[0] cmd_create = ('subnet create -f json --network {network} ' '--net-partition {net_partition} --nuagenet {nuagenet} ' '--subnet-range {subnet_range} {subnet_name}'.format( network=self.NETWORK_NAME, net_partition=user_enterprise.id, nuagenet=subnet.id, subnet_range='10.0.0.0/24', subnet_name=utils.get_random_name())) create_output = json.loads(self.openstack(cmd_create)) self.addCleanup(self.openstack, 'subnet delete {}'.format(create_output['id']))
def test_nuage_underlay_option(self): router_name = get_random_name() self.openstack('router create {}'.format(router_name)) self.addCleanup(self.openstack, 'router delete {}'.format(router_name)) subnet_name = get_random_name() self._subnet_create('subnet create -f json' ' --network {network} --subnet-range' .format(network=self.NETWORK_NAME), subnet_name) self.addCleanup(self.openstack, 'subnet delete {}'.format(subnet_name)) self.openstack('router add subnet {router} {subnet}' .format(router=router_name, subnet=subnet_name)) self.addCleanup(self.openstack, 'router remove subnet {router} {subnet}' .format(router=router_name, subnet=subnet_name)) for (param, expected) in [('', 'inherited'), ('off', 'off'), ('route', 'route'), ('snat', 'snat')]: if param: param = '--nuage-underlay ' + param self.openstack('subnet set {param} {subnet}' .format(param=param, subnet=subnet_name)) cmd_output = json.loads(self.openstack("subnet show -f json {}" .format(subnet_name))) self.assertEqual(expected=expected, observed=cmd_output['nuage_underlay'])
def test_underlay_option(self): router_name = get_random_name() self.openstack('router create {}'.format(router_name)) self.addCleanup(self.openstack, 'router delete {}'.format(router_name)) external_network_name = get_random_name() self.openstack('network create --external {}' .format(external_network_name)) self.addCleanup(self.openstack, 'network delete {}' .format(external_network_name)) for is_underlay_enabled in [True, False]: subnet_name = get_random_name() underlay_argument = ('--underlay True' if is_underlay_enabled else '--underlay False') cmd = ('subnet create -f json {underlay} --network {network} ' '--subnet-range'.format(underlay=underlay_argument, network=external_network_name)) cmd_output = self._subnet_create(cmd, subnet_name) self.assertEqual(expected=is_underlay_enabled, observed=cmd_output['underlay']) self.assertEqual(expected=False, observed=cmd_output['vsd_managed']) self.openstack('subnet delete {}'.format(subnet_name))
def setUp(self): super(NuageRedirectTargetTests, self).setUp() network = self._create_network() self.subnetl3, self.l3domain = self._create_topology( network=network['id'], cidr=netaddr.IPNetwork('10.0.0.0/24')) self.subnetl2, self.l2domain = self._create_topology( network=network['id'], cidr=netaddr.IPNetwork('20.0.0.0/24'), is_l3=False) self.nuage_rtl3 = self._create_nuage_rt( self.l3domain, name=utils.get_random_name(), end_point_type='L3', description=utils.get_random_name()) self.nuage_rtl2 = self._create_nuage_rt( self.l2domain, name=utils.get_random_name(), end_point_type='VIRTUAL_WIRE', description=utils.get_random_name()) self.portl3 = self._create_port(network_id=network['id'], subnet_id=self.subnetl3['id']) self.portl2 = self._create_port(network_id=network['id'], subnet_id=self.subnetl2['id'])
def test_nuage_redirect_target_option(self): # Note that this test only checks one redirect target per port # as it is unclear how to add multiple redirect targets at the moment # create RedirectionTarget instances on VSD rt_names = [utils.get_random_name() for _ in range(2)] rt_ids = [ self.l3domain.create_child( vspk.NURedirectionTarget(name=rt_name, endPointType='L3'))[0].id for rt_name in rt_names ] # create port with the redirect target in the VSD managed subnet # and verify port_name = utils.get_random_name() rts_arg = '--nuage-redirect-target {}'.format(rt_names[0]) cmd_create = ('port create -f json {rts_arg} ' '--network {network} {name}'.format( rts_arg=rts_arg, network=self.NETWORK_NAME, name=port_name)) cmd_output = json.loads(self.openstack(cmd_create)) self.assertEqual(observed=cmd_output['nuage_redirect_targets'], expected=rt_ids[0]) # Set rt that is already set (nothing should change) cmd_set = 'port set --nuage-redirect-target {rt_name} {port}'.format( rt_name=rt_names[0], port=port_name) cmd_output = self.openstack(cmd_set) self.assertEqual(expected='', observed=cmd_output) cmd_output = self._port_show(port_name) self.assertEqual(expected=rt_ids[0], observed=cmd_output['nuage_redirect_targets']) # Unset and verify cmd_no_rts = ('port unset --nuage-redirect-target {port}'.format( port=port_name)) cmd_output = self.openstack(cmd_no_rts) self.assertEqual(expected='', observed=cmd_output) cmd_output = self._port_show(port_name) self.assertIsNone(cmd_output['nuage_redirect_targets']) # Overwrite and verify cmd_set = ('port set --nuage-redirect-target {} {}'.format( rt_ids[1], port_name)) cmd_output = self.openstack(cmd_set) self.assertEqual(expected='', observed=cmd_output) cmd_output = self._port_show(port_name) self.assertEqual(expected=rt_ids[1], observed=cmd_output['nuage_redirect_targets']) # delete and verify utils.delete_and_verify(self, 'port', port_name)
def test_basic_create_list_show(self): netpartition1_name = get_random_name() self.create_and_verify(netpartition1_name, clean_up=False) self.list_and_verify(netpartition1_name) self.show_and_verify(netpartition1_name) delete_and_verify(self, 'nuage netpartition', netpartition1_name)
def test_create_list_show_delete_id(self): netpartition1_name = get_random_name() np, project = self._create_and_verify(netpartition1_name) self._list_and_verify(np, project) self._show_and_verify(np, project) self._delete_and_verify(project['id'])
def setUpClass(cls): super(NuageFloatingIPExtensionTests, cls).setUpClass() cls.random_name = utils.get_random_name() # Private network cls.openstack('network create {}'.format(cls.random_name)) cls.openstack(('subnet create --subnet-range 99.168.0.1/24 ' '--network {} {}'.format(cls.random_name, cls.random_name))) cls.openstack('port create --network {} {}'.format( cls.random_name, cls.random_name)) # Public network cls.openstack('network create --external public-{}'.format( cls.random_name)) cls.openstack( (('subnet create --subnet-range 98.0.2.1/24 ' '--network public-{} public-{}'.format(cls.random_name, cls.random_name)))) # Router cls.openstack('router create {}'.format(cls.random_name)) cls.openstack(('router set --external-gateway {} {}'.format( 'public-{}'.format(cls.random_name), cls.random_name))) cls.openstack( ('router add subnet {} {}'.format(cls.random_name, cls.random_name)))
def test_stateful_option(self): # test create with no option sg = self._create(name=utils.get_random_name()) self.assertIn(needle='stateful', haystack=sg) self.assertIn(needle=sg['stateful'], haystack=[True, False]) # test create with --stateful sg1 = self._create(name=utils.get_random_name(), extra_params='--stateful') self.assertIn(needle='stateful', haystack=sg1) self.assertEqual(expected=True, observed=sg1['stateful']) # test create with --no-stateful sg2 = self._create(name=utils.get_random_name(), extra_params='--no-stateful') self.assertIn(needle='stateful', haystack=sg2) self.assertEqual(expected=False, observed=sg2['stateful']) # test create with illegal option combination self.assertRaisesRegex( tempest_exceptions.CommandFailed, 'error: argument --stateful: not allowed with argument ' '--no-stateful', self._create, name=utils.get_random_name(), extra_params='--no-stateful --stateful') # test show for sg in [sg1, sg2]: output = self._show(sg['id']) self.assertIn(needle='stateful', haystack=output) self.assertEqual(expected=sg['stateful'], observed=output['stateful']) # test set (invert stateful value) for sg in [sg1, sg2]: param = '--no-stateful' if sg['stateful'] else '--stateful' output = self._set(sg['id'], param) self.assertEqual(expected='', observed=output) # test show inverted values after set for sg in [sg1, sg2]: output = self._show(sg['id']) self.assertIn(needle='stateful', haystack=output) self.assertEqual(expected=not sg['stateful'], observed=output['stateful'])
def _create_port(self, network_id, subnet_id): port_name = utils.get_random_name() cmd_create = ('port create -f json --network {network}' ' --fixed-ip subnet={subnet} {name}'.format( network=network_id, subnet=subnet_id, name=port_name)) self.addCleanup(self.openstack, 'port delete {}'.format(port_name)) return json.loads(self.openstack(cmd_create))
def _create_l3_domain_template(self): template = self.enterprise.create_child( vspk.NUDomainTemplate(name=utils.get_random_name()))[0] template.create_child(vspk.NUZoneTemplate(name='openstack-isolated')) template.create_child(vspk.NUZoneTemplate(name='openstack-shared')) self.addCleanup(template.delete) return template
def _create_shared_fip_subnet(self, session, address, netmask): shared_enterprise = session.user.enterprises.get_first( filter='name == "Shared Infrastructure"') l3_domain_template_shared_infra = \ shared_enterprise.domain_templates.get_first( filter='name == "Shared Domain template"') shared_l3_domain = shared_enterprise.create_child( vspk.NUDomain(name=utils.get_random_name(), template_id=l3_domain_template_shared_infra.id))[0] self.addCleanup(shared_l3_domain.delete) zone = shared_l3_domain.zones.get_first() shared_subnet = zone.create_child( vspk.NUSubnet(name=utils.get_random_name(), address=address, netmask=netmask, resource_type="FLOATING"))[0] self.addCleanup(shared_subnet.delete) return shared_subnet
def test_port_no_vport(self): port_name = utils.get_random_name() cmd_create = ('port create -f json --vnic-type=direct ' '--network {network} {name}'.format( network=self.NETWORK_NAME, name=port_name)) cmd_output = json.loads(self.openstack(cmd_create)) self.assertEqual(expected='direct', observed=cmd_output['binding_vnic_type']) new_port_name = utils.get_random_name() cmd_update = ('port set --name {} {}'.format(new_port_name, port_name)) cmd_output = self.openstack(cmd_update) self.assertEqual(expected='', observed=cmd_output) cmd_output = self._port_show(new_port_name) self.assertEqual(expected='direct', observed=cmd_output['binding_vnic_type']) self.assertEqual(expected=new_port_name, observed=cmd_output['name']) # delete and verify utils.delete_and_verify(self, 'port', new_port_name)
def test_show_network_nuage_options(self): network_name = utils.get_random_name() cmd_create = 'network create -f json {name}'.format(name=network_name) cmd_show = 'network show -f json {name}'.format(name=network_name) for cmd in [cmd_create, cmd_show]: cmd_output = json.loads(self.openstack(cmd)) self.assertIn(needle='nuage_l2bridge', haystack=cmd_output) self.assertIsNone(observed=cmd_output['nuage_l2bridge']) self.addCleanup(self.openstack, 'network delete {}'.format(network_name))
def _create_topology(self, network, cidr, is_l3=True): user_enterprise = self.session.user.enterprises.get_first( filter='name == "{}"'.format(utils.get_vsd_net_parition_name())) # Create VSD managed subnet if is_l3: l3domain = utils.create_l3_domain(self, user_enterprise) zone = l3domain.create_child( vspk.NUZone(name=utils.get_random_name()))[0] vsd_subnet = zone.create_child( vspk.NUSubnet(name=utils.get_random_name(), address=str(cidr.ip), netmask=str(cidr.netmask)))[0] else: l3domain = None vsd_subnet = utils.create_l2_domain(self, user_enterprise, address=str(cidr.ip), netmask=str(cidr.netmask), gateway=str(cidr.ip + 1)) subnet_create_str = ('subnet create -f json --network {network} ' '--net-partition {net_partition} ' '--nuagenet {nuagenet} ' '--subnet-range {subnet_range} {subnet_name}') if not is_l3: subnet_create_str += ' --gateway None' cmd_create = subnet_create_str.format( network=network, net_partition=user_enterprise.id, nuagenet=vsd_subnet.id, subnet_range=cidr, subnet_name=utils.get_random_name()) subnet = json.loads(self.openstack(cmd_create)) self.addCleanup(self.openstack, 'subnet delete {}'.format(subnet['id'])) return subnet, l3domain or vsd_subnet
def test_show_list(self): """Create, delete a port with a nuage floating ip""" # Create Nuage floating ips floating_ip_str_1 = '1.1.1.50' floating_ip_str_2 = '1.1.1.60' floating_ip_1 = self._create_nuage_floating_ip(floating_ip_str_1) self.addCleanup(floating_ip_1.delete) floating_ip_2 = self._create_nuage_floating_ip(floating_ip_str_2) self.addCleanup(floating_ip_2.delete) expected_1 = {'ID': floating_ip_1.id, 'Assigned': False, 'Floating_ip_address': floating_ip_str_1} expected_2 = {'ID': floating_ip_2.id, 'Assigned': False, 'Floating_ip_address': floating_ip_str_2} # Show and verify cmd_output_show = self._nuage_floatingip_show(floating_ip_2.id) self.assertEqual(expected={k.lower(): v for k, v in expected_2.items()}, observed=cmd_output_show) # Attach a floating ip to the port port_name = utils.get_random_name() self.openstack(('port create -f json --network {network} {name}' .format(network=self.network_name, name=port_name))) self.addCleanup(self.openstack, 'port delete {}'.format(port_name)) self.openstack('port set --nuage-floatingip {fip} {port}'.format( fip=expected_1['ID'], port=port_name)) expected_1['Assigned'] = True # List and verify cmd_output_list = self._nuage_floatingip_list() self.assertIn(needle=expected_1, haystack=cmd_output_list) self.assertIn(needle=expected_2, haystack=cmd_output_list) cmd_output_list = self._nuage_floatingip_list(for_port=port_name) self.assertEqual(expected=[expected_2], observed=cmd_output_list) cmd_output_list = self._nuage_floatingip_list( for_subnet=self.openstack_subnet['id']) self.assertEqual(expected=[expected_2], observed=cmd_output_list)
def test_vsd_managed_crud(self): session = create_new_vspk_session() enterprise = session.user.enterprises.get_first( filter='name == "{}"'.format(get_vsd_net_parition_name())) subnet_name = get_random_name() ip_config = get_random_ipv4_subnet_config() l2domain = create_l2_domain(self, enterprise, ip_config['address'], ip_config['netmask'], ip_config['gateway']) # CREATE / READ cmd_create = ('subnet create -f json --network {network} ' '--net-partition {net_partition} --nuagenet {nuagenet} ' '--subnet-range {subnet_range} {subnet_name} ' '--gateway None' .format(network=self.NETWORK_NAME, net_partition=enterprise.id, nuagenet=l2domain.id, subnet_range=ip_config['cidr'], subnet_name=subnet_name)) cmd_show = 'subnet show -f json {}'.format(subnet_name) for cmd in [cmd_create, cmd_show]: cmd_output = json.loads(self.openstack(cmd)) self.assertEqual(expected=True, observed=cmd_output['vsd_managed']) self.assertEqual(expected=subnet_name, observed=cmd_output['name']) self.assertEqual(expected=l2domain.id, observed=cmd_output['nuagenet']) self.assertEqual(expected=enterprise.id, observed=cmd_output['net_partition']) self.assertEqual(expected=ip_config['cidr'], observed=cmd_output['cidr']) # UPDATE update_cmd = 'subnet set --nuage-underlay route {}'.format(subnet_name) try: self.openstack(update_cmd) except exceptions.CommandFailed as e: self.assertIn(needle='is a VSD-managed subnet. Update is not ' 'supported for attributes other than ', haystack=str(e.stderr)) else: self.assertIsNotNone(None, message="Update command should fail.") # DELETE delete_and_verify(self, 'subnet', subnet_name)
def _create_network(self): network_name = utils.get_random_name() return json.loads( self.openstack('network create -f json {}'.format(network_name)))
def test_list_show_switchport_binding(self): # create a switchport binding host_id = 'fake_host_id' pci_slot = '0000:03:10.6' vlan = 123 binding_profile = dict(pci_slot=pci_slot, physical_network='physnet1', pci_vendor_info='8086:10ed') self.create_and_verify_switchport_mapping(host_id=host_id, pci_slot=pci_slot, switch_id=self.system_id, port_id=self.gw_port_name, switch_info=self.name) network_name = utils.get_random_name() self.openstack('network create --mtu 1400 --provider-network-type vlan' ' --provider-physical-network physnet1' ' --provider-segment {vlan} {network}'.format( vlan=vlan, network=network_name)) self.addCleanup(self.openstack, 'network delete {}'.format(network_name)) segment_name = utils.get_random_name() self.openstack('network segment create --network-type vxlan ' '--segment {vlan} --network {network} {segment}'.format( vlan=vlan, network=network_name, segment=segment_name)) self.addCleanup(self.openstack, 'network segment delete {}'.format(segment_name)) subnet_name = utils.get_random_name() self.openstack(('subnet create --network {network} --subnet-range ' '10.0.0.1/24 {subnet}'.format(network=network_name, subnet=subnet_name))) self.addCleanup(self.openstack, 'subnet delete {}'.format(subnet_name)) port_name = utils.get_random_name() port_cmd_output = json.loads( self.openstack( ("port create -f json --network {network} --vnic-type direct " "--binding-profile '{binding_profile}' --host {host} {port}". format(network=network_name, binding_profile=json.dumps(binding_profile), host=host_id, port=port_name)))) self.addCleanup(self.openstack, 'port delete {}'.format(port_cmd_output['id'])) # list cmd_output = json.loads( self.openstack('nuage switchport binding list -f json')) item = next((m for m in cmd_output if m['Neutron port ID'] == port_cmd_output['id']), None) self.assertIsNotNone(item) self.assertEqual(expected=5, observed=len(item)) self.assertIsNotNone(item['ID']) self.assertEqual(expected=item['Switch ID'], observed=self.system_id) self.assertEqual(expected=item['Port ID'], observed=self.gw_port_name) self.assertEqual(expected=item['Segmentation ID'], observed=vlan) # show cmd_output = json.loads( self.openstack('nuage switchport binding show {} -f json'.format( item['ID']))) self.assertIsNotNone(cmd_output) self.assertEqual(expected=7, observed=len(cmd_output)) self.assertIsNotNone(cmd_output['id']) self.assertEqual(expected=cmd_output['neutron_port_id'], observed=port_cmd_output['id']) self.assertIsNotNone(cmd_output['nuage_vport_id']) self.assertIsNotNone(cmd_output['port_uuid']) self.assertEqual(expected=cmd_output['switch_id'], observed=self.system_id) self.assertEqual(expected=cmd_output['port_id'], observed=self.gw_port_name) self.assertEqual(expected=cmd_output['segmentation_id'], observed=vlan)
def test_nuage_floating_ip_option(self): """Create, delete a port with a nuage floating ip""" # Create Nuage floating ip shared_subnet = self._create_shared_fip_subnet(self.session, '1.1.1.0', '255.255.255.0') floating_ip_str = '1.1.1.10' floating_ip = self.l3domain.create_child( vspk.NUFloatingIp( associated_shared_network_resource_id=shared_subnet.id, address=floating_ip_str))[0] self.addCleanup(floating_ip.delete) # Create a port with the Nuage floating ip in the VSD managed subnet port_name = utils.get_random_name() cmd_create = ('port create -f json --nuage-floatingip {floating_ip} ' '--network {network} {name}'.format( floating_ip=floating_ip_str, network=self.NETWORK_NAME, name=port_name)) cmd_output = json.loads(self.openstack(cmd_create)) self.addCleanup(self.openstack, 'port delete {}'.format(port_name)) # Verify create self.assertIsNotNone(cmd_output.get('nuage_floatingip')) self.assertEqual(observed=cmd_output['nuage_floatingip'], expected=osc_utils.format_dict({ 'id': floating_ip.id, 'floating_ip_address': floating_ip_str })) # Verify show cmd_output = self._port_show(port_name) self.assertEqual(observed=cmd_output['nuage_floatingip'], expected=osc_utils.format_dict({ 'id': floating_ip.id, 'floating_ip_address': floating_ip_str })) # Try to create again, expect failure cmd_create = ('port create -f json --nuage-floatingip {floating_ip} ' '--network {network} {name}'.format( floating_ip=floating_ip_str, network=self.NETWORK_NAME, name=utils.get_random_name())) self.assertRaisesRegex(Exception, "Floating IP .* is already in use", self.openstack, cmd_create) # Verify set / unset cmd_set = 'port set --nuage-floatingip 1.1.1.99 {}'.format(port_name) self.assertRaisesRegex( Exception, 'No Nuage Floating IP available with' ' IP 1.1.1.99', self.openstack, cmd_set) port_name_2 = utils.get_random_name() self.openstack('port create -f json --network {network} {name}'.format( network=self.NETWORK_NAME, name=port_name_2)) cmd_set = 'port set --nuage-floatingip {} {}'.format( floating_ip_str, port_name_2) self.assertRaisesRegex( Exception, 'Floating IP {} is already in use'.format(floating_ip_str), self.openstack, cmd_set) cmd_unset = 'port unset --nuage-floatingip {}'.format(port_name) self.openstack(cmd_unset) # Verify show (No Nuage floating ip) cmd_output = self._port_show(port_name) self.assertIsNone(cmd_output['nuage_floatingip']) # the set should work now, since we unsetted the previous fip self.openstack(cmd_set) # Verify delete utils.delete_and_verify(self, 'port', port_name_2)
def test_nuage_options(self): # TODO(glenn) Test nuage-net-partition when the resource is implemented # Create a router with Nuage arguments and verify using router show router_name = utils.get_random_name() args_for_create = { 'nuage_router_template': self._create_l3_domain_template().id, 'nuage_rd': self._random_target(), 'nuage_rt': self._random_target(), 'nuage_backhaul_vnid': 12345678, 'nuage_backhaul_rd': self._random_target(), 'nuage_backhaul_rt': self._random_target(), 'nuage_tunnel_type': 'GRE', 'nuage_ecmp_count': 3, 'nuage_underlay': 'snat' } cmd_create = ('router create -f json {args} {name}'.format( args=self._build_arg_str(args_for_create), name=router_name)) cmd_show = 'router show -f json {}'.format(router_name) for cmd in [cmd_create, cmd_show]: cmd_output = json.loads(self.openstack(cmd)) self._verify(expected=dict(args_for_create, name=router_name), observed=cmd_output) # Set Nuage arguments and verify using router show # a. update a property and check that the other ones did not change args_for_set = {'nuage_ecmp_count': 4} cmd_set = ('router set {args} {router}'.format( args=self._build_arg_str(args_for_set), router=router_name)) cmd_output = self.openstack(cmd_set) self.assertEqual(expected='', observed=cmd_output) cmd_show = 'router show -f json {}'.format(router_name) cmd_output = json.loads(self.openstack(cmd_show)) self._verify(expected=dict(args_for_create, **args_for_set), observed=cmd_output) # b. update all properties args_for_set = { 'nuage_rd': self._random_target(), 'nuage_rt': self._random_target(), 'nuage_backhaul_vnid': 16777215, 'nuage_backhaul_rd': self._random_target(), 'nuage_backhaul_rt': self._random_target(), 'nuage_tunnel_type': 'VXLAN', 'nuage_ecmp_count': 4, 'nuage_underlay': 'route', 'name': utils.get_random_name() } cmd_set = ('router set {args} {router}'.format( args=self._build_arg_str(args_for_set), router=router_name)) cmd_output = self.openstack(cmd_set) self.assertEqual(expected='', observed=cmd_output) cmd_show = 'router show -f json {}'.format(args_for_set['name']) cmd_output = json.loads(self.openstack(cmd_show)) self._verify(expected=args_for_set, observed=cmd_output) # Delete the router and verify using router list utils.delete_and_verify(self, 'router', args_for_set['name'])
def test_nuage_policygroup_option(self): # create policygroups pg_names = [utils.get_random_name() for _ in range(2)] pg_ids = [ self.l3domain.create_child( vspk.NUPolicyGroup(name=pg_name, type='SOFTWARE'))[0].id for pg_name in pg_names ] # create port with the policygroup in the VSD managed subnet and verify port_name = utils.get_random_name() pgs_arg = ' '.join('--nuage-policy-group {}'.format(name) for name in pg_names) cmd_create = ('port create -f json {pgs_arg} ' '--network {network} {name}'.format( pgs_arg=pgs_arg, network=self.NETWORK_NAME, name=port_name)) cmd_output = json.loads(self.openstack(cmd_create)) self.assertEqual(observed=cmd_output['nuage_policy_groups'], expected=osc_utils.format_list(pg_ids)) # Set pg that is already set (nothing should change) chosen_pg_id = random.choice(pg_ids) cmd_set = 'port set --nuage-policy-group {pg_id} {port}'.format( pg_id=chosen_pg_id, port=port_name) cmd_output = self.openstack(cmd_set) self.assertEqual(expected='', observed=cmd_output) cmd_output = self._port_show(port_name) self.assertEqual(expected=osc_utils.format_list(pg_ids), observed=cmd_output['nuage_policy_groups']) # Unset all and verify cmd_no_pgs = 'port set --no-nuage-policy-groups {}'.format(port_name) cmd_output = self.openstack(cmd_no_pgs) self.assertEqual(expected='', observed=cmd_output) cmd_output = self._port_show(port_name) self.assertIsNone(cmd_output['nuage_policy_groups']) # set all and verify cmd_set_all = 'port set {pgs_arg} {name}'.format(pgs_arg=pgs_arg, name=port_name) cmd_output = self.openstack(cmd_set_all) self.assertEqual(expected='', observed=cmd_output) cmd_output = self._port_show(port_name) self.assertEqual(expected=osc_utils.format_list(pg_ids), observed=cmd_output['nuage_policy_groups']) # unset one and verify cmd_unset = ('port unset --nuage-policy-group {pg} {port}'.format( pg=chosen_pg_id, port=port_name)) cmd_output = self.openstack(cmd_unset) self.assertEqual(expected='', observed=cmd_output) cmd_output = self._port_show(port_name) self.assertEqual(observed=cmd_output['nuage_policy_groups'], expected=osc_utils.format_list( filter(lambda i: i != chosen_pg_id, pg_ids))) # overwrite and verify cmd_set = ('port set --no-nuage-policy-groups ' '--nuage-policy-group {} {}'.format(chosen_pg_id, port_name)) cmd_output = self.openstack(cmd_set) self.assertEqual(expected='', observed=cmd_output) cmd_output = self._port_show(port_name) self.assertEqual(expected=osc_utils.format_list([chosen_pg_id]), observed=cmd_output['nuage_policy_groups']) # set one and verify pg_to_set = next(pg_id for pg_id in pg_ids if pg_id != chosen_pg_id) cmd_set = ('port set --nuage-policy-group {pg} {port}'.format( pg=pg_to_set, port=port_name)) cmd_output = self.openstack(cmd_set) self.assertEqual(expected='', observed=cmd_output) cmd_output = self._port_show(port_name) self.assertEqual(expected=osc_utils.format_list( [chosen_pg_id, pg_to_set]), observed=cmd_output['nuage_policy_groups']) # delete and verify utils.delete_and_verify(self, 'port', port_name)
def __init__(self, *args, **kwargs): super(NuageFloatingIPTests, self).__init__(*args, **kwargs) self.l3domain = None self.shared_subnet = None self.network_name = utils.get_random_name() self.openstack_subnet = None