def test_derive_net_settings_no_subnet(self): """ Validates the utility function settings_utils#create_network_config returns an acceptable NetworkConfig object and ensures that the new settings object will not cause the new OpenStackNetwork instance to create another network """ net_settings = NetworkConfig(name=self.network_name) self.net_creator = OpenStackNetwork(self.os_creds, net_settings) network = self.net_creator.create() derived_settings = settings_utils.create_network_config( self.neutron, network) self.assertIsNotNone(derived_settings) self.assertEqual(net_settings.name, derived_settings.name) self.assertEqual(net_settings.admin_state_up, derived_settings.admin_state_up) self.assertEqual(net_settings.external, derived_settings.external) self.assertEqual(len(net_settings.subnet_settings), len(derived_settings.subnet_settings)) net_creator = OpenStackNetwork(self.os_creds, derived_settings) derived_network = net_creator.create() self.assertEqual(network, derived_network)
def prepare_network(self): """Create network/subnet/router if they doen't exist yet""" self.logger.info( "Creating network/subnet/router if they doen't exist yet...") subnet_settings = SubnetSettings(name='%s_subnet' % self.case_name, cidr="192.168.100.0/24") network_settings = NetworkSettings(name='%s_net' % self.case_name, subnet_settings=[subnet_settings]) orchestra_network = OpenStackNetwork(self.snaps_creds, network_settings) orchestra_network_info = orchestra_network.create() self.mano['details']['network'] = {} self.mano['details']['network']['id'] = orchestra_network_info.id self.mano['details']['network']['name'] = orchestra_network_info.name self.mano['details']['external_net_name'] = snaps_utils.\ get_ext_net_name(self.snaps_creds) self.created_resources.append(orchestra_network) orchestra_router = OpenStackRouter( self.snaps_creds, RouterSettings( name='%s_router' % self.case_name, external_gateway=self.mano['details']['external_net_name'], internal_subnets=[subnet_settings.name])) orchestra_router.create() self.created_resources.append(orchestra_router) self.logger.info("Created network and router for Open Baton NFVO...")
def create_network_infrastructure(self, net_name, subnet_name, subnet_cidr, router_name): logger.info("Creating networks...") # Network and subnet subnet_settings = SubnetConfig(name=subnet_name, cidr=subnet_cidr) network_settings = NetworkConfig(name=net_name, subnet_settings=[subnet_settings]) network_creator = OpenStackNetwork(self.os_creds, network_settings) network = network_creator.create() self.creators.append(network_creator) # Router logger.info("Creating the router...") ext_network_name = env.get('EXTERNAL_NETWORK') router_settings = RouterConfig(name=router_name, external_gateway=ext_network_name, internal_subnets=[subnet_name]) router_creator = OpenStackRouter(self.os_creds, router_settings) router = router_creator.create() self.creators.append(router_creator) return network, router
def test_create_subnet_no_gateway(self): """ Tests the creation of an OpenStack network with a subnet that has a valid value assigned to the gateway IP. """ # Create Network subnet_config = SubnetConfig( name=self.guid + '-subnet', cidr=self.ip_prfx + '0/24', gateway_ip='none') net_config = NetworkConfig( name=self.guid + '-net', subnets=[subnet_config]) self.net_creator = OpenStackNetwork( self.os_creds, net_config) out_net = self.net_creator.create() # Validate network was created self.assertTrue(neutron_utils_tests.validate_network( self.neutron, self.keystone, self.net_creator.network_settings.name, True, self.os_creds.project_name)) # Validate subnets self.assertTrue(neutron_utils_tests.validate_subnet( self.neutron, out_net, self.net_creator.network_settings.subnet_settings[0].name, self.net_creator.network_settings.subnet_settings[0].cidr, True)) self.assertIsNone(out_net.subnets[0].gateway_ip)
def test_create_subnet_valid_gateway_ip(self): """ Tests the creation of an OpenStack network with a subnet that has a valid value assigned to the gateway IP. """ # Create Network subnet_config = SubnetConfig( name=self.guid + '-subnet', cidr=self.ip_prfx + '0/24', gateway_ip=self.ip_prfx + '2') net_config = NetworkConfig( name=self.guid + '-net', subnets=[subnet_config]) self.net_creator = OpenStackNetwork( self.os_creds, net_config) out_net = self.net_creator.create() self.assertIsNotNone(out_net) get_net = neutron_utils.get_network_by_id(self.neutron, out_net.id) self.assertIsNotNone(get_net) # Validate subnets self.assertTrue(neutron_utils_tests.validate_subnet( self.neutron, out_net, self.net_creator.network_settings.subnet_settings[0].name, self.net_creator.network_settings.subnet_settings[0].cidr, True)) self.assertEqual(self.ip_prfx + '2', out_net.subnets[0].gateway_ip)
def test_create_network_type_vlan_with_physical_net_and_seg_id(self): """ Tests the creation of an OpenStack network of type vlan with specified physical network and segmentation id. """ # Create Network network_type = 'vlan' # The two values must be variable to work on all OpenStack pods physical_network = 'datacentre' segmentation_id = 2366 net_settings = NetworkConfig( name=self.net_config.network_settings.name, subnet_settings=self.net_config.network_settings.subnet_settings, network_type=network_type, physical_network=physical_network, segmentation_id=segmentation_id) # When setting the network_type, creds must be admin self.net_creator = OpenStackNetwork(self.os_creds, net_settings) network = self.net_creator.create() # Validate network was created self.assertTrue(neutron_utils_tests.validate_network( self.neutron, self.keystone, net_settings.name, True, self.os_creds.project_name)) self.assertEquals(network_type, network.type)
def setUp(self): """ Setup objects required by VM instances :return: """ guid = self.__class__.__name__ + '-' + str(uuid.uuid4()) self.nova = nova_utils.nova_client(self.os_creds, self.os_session) self.cinder = cinder_utils.cinder_client( self.os_creds, self.os_session) self.image_creator = None self.network_creator = None self.flavor_creator = None self.volume_creator = None self.instance_creator = None try: image_settings = openstack_tests.cirros_image_settings( name=guid + '-image', image_metadata=self.image_metadata) self.image_creator = OpenStackImage( self.os_creds, image_settings=image_settings) self.image_creator.create() network_settings = openstack_tests.get_priv_net_config( project_name=self.os_creds.project_name, net_name="{}-{}".format(guid, 'net'), subnet_name="{}-{}".format(guid, 'subnet')).network_settings self.network_creator = OpenStackNetwork( self.os_creds, network_settings) self.network_creator.create() flavor_settings = openstack_tests.get_flavor_config( name=guid + '-flavor', ram=256, disk=10, vcpus=1, metadata=self.flavor_metadata) self.flavor_creator = OpenStackFlavor( self.os_creds, flavor_settings) self.flavor_creator.create() # Create Volume volume_settings = VolumeConfig( name=self.__class__.__name__ + '-' + str(guid)) self.volume_creator = OpenStackVolume( self.os_creds, volume_settings) self.volume_creator.create(block=True) port_settings = PortConfig( name=guid + '-port', network_name=network_settings.name) instance_settings = VmInstanceConfig( name=guid + '-vm_inst', flavor=self.flavor_creator.flavor_settings.name, port_settings=[port_settings]) self.instance_creator = OpenStackVmInstance( self.os_creds, instance_settings, image_settings) self.instance_creator.create(block=True) except: self.tearDown() raise
def test_create_with_invalid_internal_sub(self): """ Test adding an internal subnet owned by admin which should fail. """ network_settings1 = NetworkConfig( name=self.guid + '-pub-net1', subnet_settings=[ create_network.SubnetConfig(cidr=cidr1, name=self.guid + '-pub-subnet1', gateway_ip=static_gateway_ip1) ]) self.network_creator1 = OpenStackNetwork(self.admin_os_creds, network_settings1) self.network_creator1.create() self.router_settings = RouterConfig( name=self.guid + '-pub-router', external_gateway=self.ext_net_name, internal_subnets=[network_settings1.subnet_settings[0].name]) self.router_creator = create_router.OpenStackRouter( self.os_creds, self.router_settings) with self.assertRaises(RouterCreationError): self.router_creator.create()
def test_create_router_admin_ports(self): """ Test creation of a router with ports to subnets owned by the admin project """ network_settings = NetworkConfig( name=self.guid + '-pub-net1', subnet_settings=[ create_network.SubnetConfig(cidr=cidr1, name=self.guid + '-pub-subnet1', gateway_ip=static_gateway_ip1) ]) self.network_creator = OpenStackNetwork(self.admin_os_creds, network_settings) self.network_creator.create() port_settings = [ create_network.PortConfig( name=self.guid + '-port1', ip_addrs=[{ 'subnet_name': network_settings.subnet_settings[0].name, 'ip': static_gateway_ip1 }], network_name=network_settings.name) ] router_settings = RouterConfig(name=self.guid + '-pub-router', external_gateway=self.ext_net_name, port_settings=port_settings) self.router_creator = create_router.OpenStackRouter( self.os_creds, router_settings) with self.assertRaises(PortConfigError): self.router_creator.create()
def test_create_router_secure_port(self): """ Test creation of a router with a port that has a security group. """ network_settings = NetworkConfig( name=self.guid + '-pub-net1', subnet_settings=[ create_network.SubnetConfig(cidr=cidr1, name=self.guid + '-pub-subnet1') ]) self.network_creator = OpenStackNetwork(self.os_creds, network_settings) self.network_creator.create() port_settings = [ create_network.PortConfig( name=self.guid + '-port1', ip_addrs=[{ 'subnet_name': network_settings.subnet_settings[0].name, 'ip': static_gateway_ip1 }], network_name=network_settings.name, security_groups=[self.sec_grp_creator.sec_grp_settings.name]) ] router_settings = RouterConfig(name=self.guid + '-pub-router', external_gateway=self.ext_net_name, port_settings=port_settings) self.router_creator = create_router.OpenStackRouter( self.os_creds, router_settings) self.router_creator.create()
def test_create_network_router_new_user_to_admin_project(self): """ Tests the creation of an OpenStack network and router with the admin user to the new project. """ # Create Network/Subnet where the project names have been changed new_project_name = self.os_creds.project_name self.net_config.network_settings.project_name = new_project_name self.net_config.network_settings.subnet_settings[0].project_name = \ new_project_name self.net_creator = OpenStackNetwork( self.admin_os_creds, self.net_config.network_settings) self.net_creator.create() retrieved_net = neutron_utils.get_network( self.neutron, self.keystone, network_settings=self.net_config.network_settings, project_name=self.os_creds.project_name) self.assertEqual(self.net_creator.get_network().id, retrieved_net.id) # Create Router self.net_config.router_settings.project_name = new_project_name self.router_creator = create_router.OpenStackRouter( self.admin_os_creds, self.net_config.router_settings) self.router_creator.create() retrieved_router = neutron_utils.get_router( self.neutron, self.keystone, router_settings=self.router_creator.router_settings, project_name=self.os_creds.project_name) self.assertEqual( self.router_creator.get_router().id, retrieved_router.id)
def test_create_network_one_ipv6_subnet(self): """ Tests the creation of an OpenStack network without a router. """ # Create Network subnet_settings = SubnetConfig( name=self.guid + '-subnet', cidr='1:1:0:0:0:0:0:0/64', ip_version=6) network_settings = NetworkConfig( name=self.guid + '-net', subnet_settings=[subnet_settings]) self.net_creator = OpenStackNetwork(self.os_creds, network_settings) self.net_creator.create() # Validate network was created self.assertTrue(neutron_utils_tests.validate_network( self.neutron, self.keystone, self.net_creator.network_settings.name, True, self.os_creds.project_name)) network = self.net_creator.get_network() self.assertEqual(1, len(network.subnets)) subnet = network.subnets[0] self.assertEqual(network.id, subnet.network_id) self.assertEqual(subnet_settings.name, subnet.name) self.assertEqual('1:1::/64', subnet.cidr) self.assertEqual(6, subnet.ip_version) self.assertEqual(0, len(subnet.dns_nameservers))
def setUp(self): """ Setup objects required by VM instances :return: """ guid = self.__class__.__name__ + '-' + str(uuid.uuid4()) self.nova = nova_utils.nova_client( self.os_creds, self.os_session) self.keystone = keystone_utils.keystone_client( self.os_creds, self.os_session) self.neutron = neutron_utils.neutron_client( self.os_creds, self.os_session) self.glance = glance_utils.glance_client( self.os_creds, self.os_session) self.image_creator = None self.network_creator = None self.flavor_creator = None self.port = None self.vm_inst = None try: image_settings = openstack_tests.cirros_image_settings( name=guid + '-image', image_metadata=self.image_metadata) self.image_creator = OpenStackImage( self.os_creds, image_settings=image_settings) self.image_creator.create() network_settings = openstack_tests.get_priv_net_config( project_name=self.os_creds.project_name, net_name="{}-{}".format(guid, 'net'), subnet_name="{}-{}".format(guid, 'subnet')).network_settings self.network_creator = OpenStackNetwork( self.os_creds, network_settings) self.network_creator.create() flavor_config = openstack_tests.get_flavor_config( name="{}-{}".format(guid, 'flavor-name'), ram=256, disk=10, vcpus=1, metadata=self.flavor_metadata) self.flavor_creator = OpenStackFlavor(self.os_creds, flavor_config) self.flavor_creator.create() port_settings = PortConfig( name=guid + '-port', network_name=network_settings.name) self.port = neutron_utils.create_port( self.neutron, self.os_creds, port_settings) self.instance_settings = VmInstanceConfig( name=guid + '-vm_inst', flavor=self.flavor_creator.flavor_settings.name, port_settings=[port_settings]) except: self.tearDown() raise
def test_create_network_type_foo(self): """ Tests the creation of an OpenStack network of type foo which should raise an exception. """ # Create Network network_type = 'foo' net_settings = NetworkConfig( name=self.net_config.network_settings.name, subnet_settings=self.net_config.network_settings.subnet_settings, network_type=network_type) self.net_creator = OpenStackNetwork(self.os_creds, net_settings) with self.assertRaises(Exception): self.net_creator.create()
def test_create_subnet_invalid_gateway_ip(self): """ Tests the creation of an OpenStack network with a subnet that has an invalid value assigned to the gateway IP. """ # Create Network subnet_config = SubnetConfig( name=self.guid + '-subnet', cidr=self.ip_prfx + '0/24', gateway_ip='foo') net_config = NetworkConfig( name=self.guid + '-net', subnets=[subnet_config]) self.net_creator = OpenStackNetwork( self.os_creds, net_config) with self.assertRaises(BadRequest): self.net_creator.create()
def test_create_networks_same_name(self): """ Tests the creation of an OpenStack network and ensures that the OpenStackNetwork object will not create a second. """ # Create Network self.net_creator = OpenStackNetwork( self.os_creds, self.net_config.network_settings) self.net_creator.create() self.net_creator2 = OpenStackNetwork( self.os_creds, self.net_config.network_settings) self.net_creator2.create() self.assertEqual(self.net_creator.get_network().id, self.net_creator2.get_network().id)
def test_derive_net_settings_two_subnets(self): """ Validates the utility function settings_utils#create_network_config returns an acceptable NetworkConfig object """ subnet_settings = list() subnet_settings.append(SubnetConfig(name='sub1', cidr='10.0.0.0/24')) subnet_settings.append(SubnetConfig(name='sub2', cidr='10.0.1.0/24')) net_settings = NetworkConfig(name=self.network_name, subnet_settings=subnet_settings) self.net_creator = OpenStackNetwork(self.os_creds, net_settings) network = self.net_creator.create() derived_settings = settings_utils.create_network_config( self.neutron, network) self.assertIsNotNone(derived_settings) self.assertEqual(net_settings.name, derived_settings.name) self.assertEqual(net_settings.admin_state_up, derived_settings.admin_state_up) self.assertEqual(net_settings.external, derived_settings.external) self.assertEqual(len(net_settings.subnet_settings), len(derived_settings.subnet_settings)) # Validate the first subnet orig_sub1 = net_settings.subnet_settings[0] found = False for derived_sub in derived_settings.subnet_settings: if orig_sub1.name == derived_sub.name: self.assertEqual(orig_sub1.cidr, derived_sub.cidr) found = True self.assertTrue(found) # Validate the second subnet orig_sub2 = net_settings.subnet_settings[1] found = False for derived_sub in derived_settings.subnet_settings: if orig_sub2.name == derived_sub.name: self.assertEqual(orig_sub2.cidr, derived_sub.cidr) self.assertEqual(orig_sub2.ip_version, derived_sub.ip_version) found = True self.assertTrue(found)
def test_create_network_ipv4_ipv6_subnet(self): """ Tests the creation of an OpenStack network without a router. """ # Create Network subnet4_settings = SubnetConfig( name=self.guid + '-subnet4', cidr='10.0.1.0/24', ip_version=4) subnet6_settings = SubnetConfig( name=self.guid + '-subnet6', cidr='1:1:0:0:0:0:0:0/64', ip_version=6) network_settings = NetworkConfig( name=self.guid + '-net', subnet_settings=[subnet4_settings, subnet6_settings]) self.net_creator = OpenStackNetwork(self.os_creds, network_settings) self.net_creator.create() # Validate network was created network = self.net_creator.get_network() self.assertEqual(2, len(network.subnets)) subnet4 = None subnet6 = None for subnet in network.subnets: if subnet.name == subnet4_settings.name: subnet4 = subnet if subnet.name == subnet6_settings.name: subnet6 = subnet # Validate IPv4 subnet self.assertEqual(network.id, subnet4.network_id) self.assertEqual(subnet4_settings.name, subnet4.name) self.assertEqual(subnet4_settings.cidr, subnet4.cidr) self.assertEqual(4, subnet4.ip_version) self.assertEqual(0, len(subnet4.dns_nameservers)) # Validate IPv6 subnet self.assertEqual(network.id, subnet6.network_id) self.assertEqual(subnet6_settings.name, subnet6.name) self.assertEqual('1:1::/64', subnet6.cidr) self.assertEqual(6, subnet6.ip_version) self.assertEqual(0, len(subnet6.dns_nameservers))
def test_create_router_external_network(self): """ Test creation of a router connected to an external network and a private network. """ network_settings = NetworkConfig( name=self.guid + '-pub-net1', subnet_settings=[ create_network.SubnetConfig(cidr=cidr1, name=self.guid + '-pub-subnet1', gateway_ip=static_gateway_ip1) ]) self.network_creator1 = OpenStackNetwork(self.os_creds, network_settings) self.network_creator1.create() port_settings = [ create_network.PortConfig( name=self.guid + '-port1', ip_addrs=[{ 'subnet_name': network_settings.subnet_settings[0].name, 'ip': static_gateway_ip1 }], network_name=network_settings.name) ] router_settings = RouterConfig(name=self.guid + '-pub-router', external_gateway=self.ext_net_name, port_settings=port_settings) self.router_creator = create_router.OpenStackRouter( self.os_creds, router_settings) self.router_creator.create() router = neutron_utils.get_router( self.neutron, self.keystone, router_settings=router_settings, project_name=self.os_creds.project_name) self.assertEquals(router, self.router_creator.get_router()) self.check_router_recreation(router, router_settings)
def test_create_network_without_router(self): """ Tests the creation of an OpenStack network without a router. """ # Create Network self.net_creator = OpenStackNetwork( self.os_creds, self.net_config.network_settings) network = self.net_creator.create() # Validate network was created self.assertTrue(neutron_utils_tests.validate_network( self.neutron, self.keystone, self.net_creator.network_settings.name, True, self.os_creds.project_name, mtu=999)) # Validate subnets self.assertTrue(neutron_utils_tests.validate_subnet( self.neutron, network, self.net_creator.network_settings.subnet_settings[0].name, self.net_creator.network_settings.subnet_settings[0].cidr, True))
def get_network_creators(self): """ Returns a list of network creator objects as configured by the heat template :return: list() of OpenStackNetwork objects """ out = list() stack_networks = heat_utils.get_stack_networks(self.__heat_cli, self.__neutron, self.__stack) for stack_network in stack_networks: net_settings = settings_utils.create_network_config( self.__neutron, stack_network) net_creator = OpenStackNetwork(self._os_creds, net_settings) out.append(net_creator) net_creator.initialize() return out
def test_create_network_type_vxlan(self): """ Tests the creation of an OpenStack network of type vxlan. """ # Create Network network_type = 'vxlan' net_settings = NetworkConfig( name=self.net_config.network_settings.name, subnet_settings=self.net_config.network_settings.subnet_settings, network_type=network_type) # When setting the network_type, creds must be admin self.net_creator = OpenStackNetwork(self.os_creds, net_settings) network = self.net_creator.create() # Validate network was created self.assertTrue(neutron_utils_tests.validate_network( self.neutron, self.keystone, net_settings.name, True, self.os_creds.project_name)) self.assertEqual(network_type, network.type)
def test_create_network_router_admin_user_to_new_project(self): """ Tests the creation of an OpenStack network to the the current using the credentials to the admin project. """ # Create Network/Subnet where the project names have been changed project_name = self.os_creds.project_name config = self.net_config.network_settings config.project_name = project_name config.subnet_settings[0].project_name = project_name self.net_creator = OpenStackNetwork(self.admin_os_creds, config) self.net_creator.create() retrieved_net = neutron_utils.get_network( self.neutron, self.keystone, network_name=self.net_config.network_settings.name, project_name=self.os_creds.project_name) self.assertEqual(self.net_creator.get_network().id, retrieved_net.id) # Initialize with actual credentials config.project_name = None config.subnet_settings[0].project_name = None proj_net_creator = OpenStackNetwork(self.os_creds, config) proj_net = proj_net_creator.create() self.assertEqual(retrieved_net, proj_net) # Create Router self.net_config.router_settings.project_name = project_name self.router_creator = create_router.OpenStackRouter( self.admin_os_creds, self.net_config.router_settings) self.router_creator.create() retrieved_router = neutron_utils.get_router( self.neutron, self.keystone, router_settings=self.router_creator.router_settings, project_name=self.os_creds.project_name) self.assertEqual( self.router_creator.get_router().id, retrieved_router.id)
def create_network(os_creds, network_settings, cleanup=False): """ Creates a network on which the CMTSs can attach :param os_creds: The OpenStack credentials object :param network_settings: The network settings object :param cleanup: Denotes whether or not this is being called for cleanup :return: A reference to the network creator objects for each network from which network elements such as the subnet, router, interface router, and network objects can be accessed. """ # Check for OS for network existence # If exists return network instance data # Else, create network and return instance data logger.info('Attempting to create network with name - %s', network_settings.name) network_creator = OpenStackNetwork(os_creds, network_settings) if cleanup: network_creator.initialize() else: network_creator.create() logger.info('Created network ') return network_creator
def test_network_create_by_admin_to_different_project(self): """ Tests the creation of an OpenStackNetwork by the admin user and initialize again with tenant credentials. """ # Create Network net_settings = self.net_config.network_settings net_settings.project_name = self.os_creds.project_name self.admin_net_creator = OpenStackNetwork( self.admin_os_creds, net_settings) self.admin_net_creator.create() self.proj_net_creator = OpenStackNetwork( self.os_creds, self.net_config.network_settings) self.proj_net_creator.create() self.assertEqual( self.admin_net_creator.get_network().id, self.proj_net_creator.get_network().id)
def test_create_network_type_flat(self): """ Tests the creation of an OpenStack network of type flat. """ # Create Network network_type = 'flat' # This value must be variable to work on all OpenStack pods physical_network = 'datacentre' net_settings = NetworkConfig( name=self.net_config.network_settings.name, subnet_settings=self.net_config.network_settings.subnet_settings, network_type=network_type, physical_network=physical_network) self.net_creator = OpenStackNetwork(self.os_creds, net_settings) network = self.net_creator.create() # Validate network was created self.assertTrue(neutron_utils_tests.validate_network( self.neutron, self.keystone, net_settings.name, True, self.os_creds.project_name)) self.assertEquals(network_type, network.type)
def setUp(self): """ Initializes objects used for router testing """ super(self.__class__, self).__start__() self.guid = self.__class__.__name__ + '-' + str(uuid.uuid4()) self.admin_router_creator = None self.proj_router_creator = None self.neutron = neutron_utils.neutron_client(self.os_creds, self.os_session) network_settings = NetworkConfig( name=self.guid + '-pub-net', shared=True, subnet_settings=[ create_network.SubnetConfig(cidr=cidr1, name=self.guid + '-pub-subnet', gateway_ip=static_gateway_ip1) ]) self.network_creator = OpenStackNetwork(self.admin_os_creds, network_settings) self.network_creator.create()
def test_create_with_internal_sub(self): """ Test internal_subnets works. """ network_settings1 = NetworkConfig( name=self.guid + '-pub-net1', subnet_settings=[ create_network.SubnetConfig(cidr=cidr1, name=self.guid + '-pub-subnet1', gateway_ip=static_gateway_ip1) ]) self.network_creator1 = OpenStackNetwork(self.os_creds, network_settings1) self.network_creator1.create() self.router_settings = RouterConfig( name=self.guid + '-pub-router', external_gateway=self.ext_net_name, internal_subnets=[network_settings1.subnet_settings[0].name]) self.router_creator = create_router.OpenStackRouter( self.os_creds, self.router_settings) created_router = self.router_creator.create() self.assertIsNotNone(created_router)
def test_create_delete_network(self): """ Tests the creation of an OpenStack network, it's deletion, then cleanup """ # Create Network self.net_creator = OpenStackNetwork( self.os_creds, self.net_config.network_settings) self.net_creator.create() # Validate network was created self.assertTrue(neutron_utils_tests.validate_network( self.neutron, self.keystone, self.net_creator.network_settings.name, True, self.os_creds.project_name, mtu=999)) neutron_utils.delete_network( self.neutron, self.net_creator.get_network()) self.assertIsNone(neutron_utils.get_network( self.neutron, self.keystone, network_settings=self.net_creator.network_settings, project_name=self.os_creds.project_name)) # This shall not throw an exception here self.net_creator.clean()
def test_create_network_with_router(self): """ Tests the creation of an OpenStack network with a router. """ # Create Network self.net_creator = OpenStackNetwork( self.os_creds, self.net_config.network_settings) network = self.net_creator.create() # Create Router self.router_creator = create_router.OpenStackRouter( self.os_creds, self.net_config.router_settings) self.router_creator.create() # Validate network was created self.assertTrue(neutron_utils_tests.validate_network( self.neutron, self.keystone, self.net_creator.network_settings.name, True, self.os_creds.project_name, mtu=999)) # Validate subnets self.assertTrue(neutron_utils_tests.validate_subnet( self.neutron, network, self.net_creator.network_settings.subnet_settings[0].name, self.net_creator.network_settings.subnet_settings[0].cidr, True)) # Validate routers neutron_utils_tests.validate_router( self.neutron, self.keystone, self.router_creator.router_settings.name, self.os_creds.project_name, True) neutron_utils_tests.validate_interface_router( self.router_creator.get_internal_router_interface(), self.router_creator.get_router(), self.net_creator.get_network().subnets[0])