def test_network_same_name_diff_proj(self):
"""
Tests the creation of an OpenStackNetwork with the same name
within a different project/tenant when not configured but implied by
the OSCreds.
"""
# Create Network
self.admin_net_creator = OpenStackNetwork(
self.admin_os_creds, self.net_config.network_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.assertNotEqual(
self.admin_net_creator.get_network().id,
self.proj_net_creator.get_network().id)
admin_creator2 = OpenStackNetwork(
self.admin_os_creds, self.net_config.network_settings)
admin_creator2.create()
self.assertEqual(
self.admin_net_creator.get_network(), admin_creator2.get_network())
proj_creator2 = OpenStackNetwork(
self.os_creds, self.net_config.network_settings)
proj_creator2.create()
self.assertEqual(self.proj_net_creator.get_network(),
proj_creator2.get_network())
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 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 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_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 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_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 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_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_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_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_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 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 setUp(self):
"""
Initializes objects used for router testing
"""
super(self.__class__, self).__start__()
self.guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
self.router_creator = None
ext_network_settings = NetworkConfig(
name=self.guid + '-ext-net',
external=True,
subnet_settings=[
create_network.SubnetConfig(cidr=cidr1,
name=self.guid + '-ext-subnet1')
])
self.ext_network_creator = OpenStackNetwork(self.admin_os_creds,
ext_network_settings)
self.ext_network_creator.create()
shared_network_settings = NetworkConfig(
name=self.guid + '-shared-net',
shared=True,
subnet_settings=[
create_network.SubnetConfig(cidr=cidr2,
name=self.guid + '-shared-subnet1')
])
self.shared_network_creator = OpenStackNetwork(
self.admin_os_creds, shared_network_settings)
self.shared_network_creator.create()
overlay_network_settings = NetworkConfig(
name=self.guid + '-overlay-net',
subnet_settings=[
create_network.SubnetConfig(cidr=cidr3,
name=self.guid +
'-overlay-subnet1')
])
self.overlay_network_creator = OpenStackNetwork(
self.os_creds, overlay_network_settings)
self.overlay_network_creator.create()
self.neutron = neutron_utils.neutron_client(self.os_creds,
self.os_session)
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_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 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_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_vping_ssh(self, create_vm, path_exists, flavor_create,
get_port_ip, vm_active, ssh_active, ssh_client,
scp_client, trans_script, do_vping_ssh, ext_net_name):
os_vm_inst = mock.MagicMock(name='get_console_output')
os_vm_inst.get_console_output.return_value = 'vPing OK'
ssh_client = mock.MagicMock(name='get_transport')
ssh_client.get_transport.return_value = None
scp_client = mock.MagicMock(name='put')
scp_client.put.return_value = None
with mock.patch('snaps.openstack.utils.deploy_utils.create_image',
return_value=OpenStackImage(self.os_creds, None)), \
mock.patch('snaps.openstack.utils.deploy_utils.create_network',
return_value=OpenStackNetwork(
self.os_creds,
NetworkConfig(
name='foo',
subnet_settings=[
SubnetConfig(
name='bar',
cidr='10.0.0.1/24')]))), \
mock.patch('snaps.openstack.utils.deploy_utils.'
'create_vm_instance',
return_value=OpenStackVmInstance(
self.os_creds,
VmInstanceConfig(
name='foo', flavor='bar',
port_settings=[PortConfig(
name='foo', network_name='bar')]),
None)), \
mock.patch('snaps.openstack.utils.deploy_utils.create_keypair',
return_value=OpenStackKeypair(
self.os_creds, KeypairConfig(name='foo'))), \
mock.patch('snaps.openstack.utils.deploy_utils.create_router',
return_value=OpenStackRouter(
self.os_creds, RouterConfig(name='foo'))), \
mock.patch('snaps.openstack.utils.deploy_utils.'
'create_security_group',
return_value=OpenStackSecurityGroup(
self.os_creds,
SecurityGroupConfig(name='foo'))), \
mock.patch('snaps.openstack.create_instance.'
'OpenStackVmInstance.'
'get_vm_inst', return_value=os_vm_inst), \
mock.patch('snaps.openstack.create_instance.'
'OpenStackVmInstance.'
'ssh_client', return_value=ssh_client):
self.assertEquals(TestCase.EX_OK, self.vping_ssh.run())
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_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 test_vping_userdata(self, deploy_vm, path_exists, create_flavor,
get_port_ip, vm_active):
with mock.patch('snaps.openstack.utils.deploy_utils.create_image',
return_value=OpenStackImage(self.os_creds, None)), \
mock.patch('snaps.openstack.utils.deploy_utils.create_network',
return_value=OpenStackNetwork(
self.os_creds, NetworkConfig(name='foo'))), \
mock.patch('snaps.openstack.utils.deploy_utils.'
'create_vm_instance',
return_value=OpenStackVmInstance(
self.os_creds,
VmInstanceConfig(
name='foo', flavor='bar',
port_settings=[PortConfig(
name='foo', network_name='bar')]),
None)), \
mock.patch('snaps.openstack.create_instance.'
'OpenStackVmInstance.get_console_output',
return_value='vPing OK'):
self.assertEquals(TestCase.EX_OK, self.vping_userdata.run())
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_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)