class CreateRouterSharedNetworksTests(OSIntegrationTestCase):
"""
Class for testing routers external and/or shared networks
"""
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 tearDown(self):
"""
Cleans the remote OpenStack objects used for router testing
"""
if self.router_creator:
self.router_creator.clean()
if self.overlay_network_creator:
self.overlay_network_creator.clean()
if self.shared_network_creator:
self.shared_network_creator.clean()
if self.ext_network_creator:
self.ext_network_creator.clean()
super(self.__class__, self).__clean__()
def test_create_router_external(self):
"""
Test creation of a router with a custom external network created by
admin.
"""
router_settings = RouterConfig(
name=self.guid + '-pub-router',
external_gateway=self.ext_network_creator.get_network().name)
self.router_creator = create_router.OpenStackRouter(
self.os_creds, router_settings)
self.router_creator.create()
def test_create_router_port_external(self):
"""
Test creation of a router with a port to an custom external network
created by admin.
"""
router_settings = RouterConfig(
name=self.guid + '-pub-router',
network_name=self.ext_network_creator.get_network().name)
self.router_creator = create_router.OpenStackRouter(
self.os_creds, router_settings)
self.router_creator.create()
def test_create_router_port_shared(self):
"""
Test creation of a router with a port to an custom shared network
created by admin.
"""
port_settings = [
create_network.PortConfig(
name=self.guid + '-port1',
network_name=self.shared_network_creator.get_network().name)
]
router_settings = RouterConfig(name=self.guid + '-pub-router',
port_settings=port_settings)
self.router_creator = create_router.OpenStackRouter(
self.os_creds, router_settings)
self.router_creator.create()
class CreateMultipleRouterTests(OSIntegrationTestCase):
"""
Test for the OpenStackRouter class and how it interacts with routers
groups within other projects with the same name
"""
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 tearDown(self):
"""
Cleans the remote OpenStack objects used for router testing
"""
if self.admin_router_creator:
self.admin_router_creator.clean()
if self.proj_router_creator:
self.proj_router_creator.clean()
if self.network_creator:
self.network_creator.clean()
super(self.__class__, self).__clean__()
def test_router_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 Router
router_config = RouterConfig(name=self.guid + '-router')
self.admin_router_creator = OpenStackRouter(self.admin_os_creds,
router_config)
self.admin_router_creator.create()
self.proj_router_creator = OpenStackRouter(self.os_creds,
router_config)
self.proj_router_creator.create()
self.assertNotEqual(self.admin_router_creator.get_router().id,
self.proj_router_creator.get_router().id)
admin_creator2 = OpenStackRouter(self.admin_os_creds, router_config)
admin_creator2.create()
self.assertEqual(self.admin_router_creator.get_router(),
admin_creator2.get_router())
proj_creator2 = OpenStackRouter(self.os_creds, router_config)
proj_creator2.create()
self.assertEqual(self.proj_router_creator.get_router(),
proj_creator2.get_router())
def test_router_create_by_admin_to_different_project(self):
"""
Tests the creation of an OpenStackRouter by the admin user and
initialize again with tenant credentials.
"""
# Create Network
admin_router_config = RouterConfig(
name=self.guid + '-router',
project_name=self.os_creds.project_name)
self.admin_router_creator = OpenStackRouter(self.admin_os_creds,
admin_router_config)
self.admin_router_creator.create()
proj_router_config = RouterConfig(
name=self.guid + '-router',
project_name=self.os_creds.project_name)
self.proj_router_creator = OpenStackRouter(self.os_creds,
proj_router_config)
self.proj_router_creator.create()
self.assertEqual(self.admin_router_creator.get_router().id,
self.proj_router_creator.get_router().id)
subnet_settings=[subnet_settings])
network = OpenStackNetwork(os_creds, network_settings)
network.create()
# Flavors
from snaps.config.flavor import FlavorConfig
from snaps.openstack.create_flavor import OpenStackFlavor
flavor_settings = FlavorConfig(name='test-flavor', ram=256, disk=10, vcpus=2)
flavor = OpenStackFlavor(os_creds, flavor_settings)
flavor.create()
# Instances
from snaps.config.network import PortConfig
from snaps.openstack.create_instance import OpenStackVmInstance
port_settings = PortConfig(name='test-port',
network_name=network_settings.name)
instance_settings = VmInstanceConfig(name='test-inst',
flavor=flavor_settings.name,
port_settings=[port_settings])
vm_inst = OpenStackVmInstance(os_creds, instance_settings, image_settings)
vm_inst.create(block=True)
# Cleanup
vm_inst.clean()
flavor.clean()
network.clean()
image.clean()
class CreateNetworkSuccessTests(OSIntegrationTestCase):
"""
Test for the CreateNetwork class defined in create_nework.py
"""
def setUp(self):
"""
Sets up object for test
"""
super(self.__class__, self).__start__()
guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
self.net_config = openstack_tests.get_pub_net_config(
project_name=self.os_creds.project_name,
net_name="{}-{}".format(guid, 'pub-net'), mtu=999,
subnet_name="{}-{}".format(guid, 'pub-subnet'),
router_name="{}-{}".format(guid, 'pub-router'),
external_net=self.ext_net_name,
netconf_override=self.netconf_override)
self.neutron = neutron_utils.neutron_client(
self.os_creds, self.os_session)
# Initialize for cleanup
self.net_creator = None
self.router_creator = None
def tearDown(self):
"""
Cleans the network
"""
if self.router_creator:
self.router_creator.clean()
if self.net_creator:
self.net_creator.clean()
super(self.__class__, self).__clean__()
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_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])
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_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_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)
class NovaUtilsInstanceVolumeTests(OSComponentTestCase):
"""
Tests the creation of VM instances via nova_utils.py
"""
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 tearDown(self):
"""
Cleanup deployed resources
:return:
"""
if self.instance_creator:
try:
self.instance_creator.clean()
except:
pass
if self.volume_creator:
try:
self.volume_creator.clean()
except:
pass
if self.flavor_creator:
try:
self.flavor_creator.clean()
except:
pass
if self.network_creator:
try:
self.network_creator.clean()
except:
pass
if self.image_creator:
try:
self.image_creator.clean()
except:
pass
super(self.__class__, self).__clean__()
def test_add_remove_volume(self):
"""
Tests the nova_utils.attach_volume() and detach_volume functions with
a timeout value
:return:
"""
self.assertIsNotNone(self.volume_creator.get_volume())
self.assertEqual(0, len(self.volume_creator.get_volume().attachments))
# Attach volume to VM
neutron = neutron_utils.neutron_client(
self.os_creds, self.os_session)
keystone = keystone_utils.keystone_client(
self.os_creds, self.os_session)
self.assertIsNotNone(nova_utils.attach_volume(
self.nova, neutron, keystone, self.instance_creator.get_vm_inst(),
self.volume_creator.get_volume(), self.os_creds.project_name))
vol_attach = None
vol_detach = None
attached = False
start_time = time.time()
while time.time() < start_time + 120:
vol_attach = cinder_utils.get_volume_by_id(
self.cinder, self.volume_creator.get_volume().id)
if len(vol_attach.attachments) > 0:
attached = True
break
time.sleep(3)
self.assertTrue(attached)
self.assertIsNotNone(vol_attach)
keystone = keystone_utils.keystone_client(
self.os_creds, self.os_session)
vm_attach = nova_utils.get_server_object_by_id(
self.nova, neutron, keystone,
self.instance_creator.get_vm_inst().id, self.os_creds.project_name)
# Validate Attachment
self.assertIsNotNone(vol_attach)
self.assertEqual(self.volume_creator.get_volume().id, vol_attach.id)
self.assertEqual(1, len(vol_attach.attachments))
self.assertEqual(vm_attach.volume_ids[0]['id'],
vol_attach.attachments[0]['volume_id'])
# Detach volume to VM
self.assertIsNotNone(nova_utils.detach_volume(
self.nova, neutron, keystone, self.instance_creator.get_vm_inst(),
self.volume_creator.get_volume(), self.os_creds.project_name))
start_time = time.time()
while time.time() < start_time + 120:
vol_detach = cinder_utils.get_volume_by_id(
self.cinder, self.volume_creator.get_volume().id)
if len(vol_detach.attachments) == 0:
attached = False
break
time.sleep(3)
self.assertFalse(attached)
self.assertIsNotNone(vol_detach)
vm_detach = nova_utils.get_server_object_by_id(
self.nova, neutron, keystone,
self.instance_creator.get_vm_inst().id, self.os_creds.project_name)
# Validate Detachment
self.assertIsNotNone(vol_detach)
self.assertEqual(self.volume_creator.get_volume().id, vol_detach.id)
self.assertEqual(0, len(vol_detach.attachments))
self.assertEqual(0, len(vm_detach.volume_ids))
def test_attach_volume_nowait(self):
"""
Tests the nova_utils.attach_volume() with a timeout value that is too
small to have the volume attachment data to be included on the VmInst
object that was supposed to be returned
"""
self.assertIsNotNone(self.volume_creator.get_volume())
self.assertEqual(0, len(self.volume_creator.get_volume().attachments))
# Attach volume to VM
neutron = neutron_utils.neutron_client(self.os_creds, self.os_session)
keystone = keystone_utils.keystone_client(
self.os_creds, self.os_session)
with self.assertRaises(NovaException):
nova_utils.attach_volume(
self.nova, neutron, keystone,
self.instance_creator.get_vm_inst(),
self.volume_creator.get_volume(), self.os_creds.project_name,
0)
def test_detach_volume_nowait(self):
"""
Tests the nova_utils.detach_volume() with a timeout value that is too
small to have the volume attachment data to be included on the VmInst
object that was supposed to be returned
"""
self.assertIsNotNone(self.volume_creator.get_volume())
self.assertEqual(0, len(self.volume_creator.get_volume().attachments))
# Attach volume to VM
neutron = neutron_utils.neutron_client(self.os_creds, self.os_session)
keystone = keystone_utils.keystone_client(
self.os_creds, self.os_session)
nova_utils.attach_volume(
self.nova, neutron, keystone, self.instance_creator.get_vm_inst(),
self.volume_creator.get_volume(), self.os_creds.project_name)
# Check VmInst for attachment
keystone = keystone_utils.keystone_client(
self.os_creds, self.os_session)
latest_vm = nova_utils.get_server_object_by_id(
self.nova, neutron, keystone,
self.instance_creator.get_vm_inst().id, self.os_creds.project_name)
self.assertEqual(1, len(latest_vm.volume_ids))
# Check Volume for attachment
vol_attach = None
attached = False
start_time = time.time()
while time.time() < start_time + 120:
vol_attach = cinder_utils.get_volume_by_id(
self.cinder, self.volume_creator.get_volume().id)
if len(vol_attach.attachments) > 0:
attached = True
break
time.sleep(3)
self.assertTrue(attached)
self.assertIsNotNone(vol_attach)
# Detach volume
with self.assertRaises(NovaException):
nova_utils.detach_volume(
self.nova, neutron, keystone,
self.instance_creator.get_vm_inst(),
self.volume_creator.get_volume(), self.os_creds.project_name,
0)
class NovaUtilsInstanceTests(OSComponentTestCase):
"""
Tests the creation of VM instances via nova_utils.py
"""
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 tearDown(self):
"""
Cleanup deployed resources
:return:
"""
if self.vm_inst:
try:
nova_utils.delete_vm_instance(self.nova, self.vm_inst)
except:
pass
if self.port:
try:
neutron_utils.delete_port(self.neutron, self.port)
except:
pass
if self.flavor_creator:
try:
self.flavor_creator.clean()
except:
pass
if self.network_creator:
try:
self.network_creator.clean()
except:
pass
if self.image_creator:
try:
self.image_creator.clean()
except:
pass
super(self.__class__, self).__clean__()
def test_create_instance(self):
"""
Tests the nova_utils.create_server() method
:return:
"""
self.vm_inst = nova_utils.create_server(
self.nova, self.keystone, self.neutron, self.glance,
self.instance_settings, self.image_creator.image_settings,
self.os_creds.project_name)
self.assertIsNotNone(self.vm_inst)
# Wait until instance is ACTIVE
iters = 0
active = False
status = None
while iters < 60:
status = nova_utils.get_server_status(self.nova, self.vm_inst)
if create_instance.STATUS_ACTIVE == status:
active = True
break
time.sleep(3)
iters += 1
self.assertTrue(active, msg='VM {} status {} is not {}'.format(
self.vm_inst.name, status, create_instance.STATUS_ACTIVE))
vm_inst = nova_utils.get_latest_server_object(
self.nova, self.neutron, self.keystone, self.vm_inst,
self.os_creds.project_name)
self.assertEqual(self.vm_inst.name, vm_inst.name)
self.assertEqual(self.vm_inst.id, vm_inst.id)