def test_create_delete_volume(self):
"""
Tests the creation then deletion of an OpenStack volume to ensure
clean() does not raise an Exception.
"""
# Create Volume
self.volume_creator = OpenStackVolume(self.os_creds,
self.volume_settings)
created_volume = self.volume_creator.create(block=True)
self.assertIsNotNone(created_volume)
retrieved_volume = cinder_utils.get_volume(
self.cinder,
self.keystone,
volume_settings=self.volume_settings,
project_name=self.os_creds.project_name)
self.assertIsNotNone(retrieved_volume)
self.assertEqual(created_volume, retrieved_volume)
# Delete Volume manually
self.volume_creator.clean()
self.assertIsNone(
cinder_utils.get_volume(self.cinder,
self.keystone,
volume_settings=self.volume_settings,
project_name=self.os_creds.project_name))
# Must not throw an exception when attempting to cleanup non-existent
# volume
self.volume_creator.clean()
self.assertIsNone(self.volume_creator.get_volume())
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_bad_volume_type(self):
"""
Expect a NotFound to be raised when the volume type does not exist
"""
self.volume_creator = OpenStackVolume(
self.os_creds, VolumeConfig(name=self.volume_name,
type_name='foo'))
with self.assertRaises(NotFound):
self.volume_creator.create()
def test_bad_image_name(self):
"""
Tests OpenStackVolume#create() method to ensure a volume is NOT created
when associating it to an invalid image name
"""
self.volume_creator = OpenStackVolume(
self.os_creds, VolumeConfig(name=self.volume_name,
image_name='foo'))
with self.assertRaises(BadRequest):
self.volume_creator.create(block=True)
def test_valid_volume_type(self):
"""
Expect a NotFound to be raised when the volume type does not exist
"""
self.volume_creator = OpenStackVolume(
self.admin_os_creds,
VolumeConfig(name=self.volume_name,
type_name=self.volume_type_name))
created_volume = self.volume_creator.create(block=True)
self.assertIsNotNone(created_volume)
self.assertEqual(self.volume_type_name, created_volume.type)
def test_create_volume_bad_size(self):
"""
Tests the creation of an OpenStack volume with a negative size to
ensure it raises a BadRequest exception.
"""
volume_settings = VolumeConfig(name=self.__class__.__name__ + '-' +
str(self.guid),
size=-1)
# Create Volume
self.volume_creator = OpenStackVolume(self.os_creds, volume_settings)
with self.assertRaises(BadRequest):
self.volume_creator.create(block=True)
def test_create_volume_bad_image(self):
"""
Tests the creation of an OpenStack volume with an image that does not
exist to ensure it raises a BadRequest exception.
"""
volume_settings = VolumeConfig(name=self.__class__.__name__ + '-' +
str(self.guid),
image_name='foo')
# Create Volume
self.volume_creator = OpenStackVolume(self.os_creds, volume_settings)
with self.assertRaises(BadRequest):
self.volume_creator.create(block=True)
class CreateVolumeWithTypeTests(OSIntegrationTestCase):
"""
Test cases for the CreateVolume when attempting to associate it to a
Volume Type
"""
def setUp(self):
super(self.__class__, self).__start__()
guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
self.volume_name = guid + '-vol'
self.volume_type_name = guid + '-vol-type'
self.volume_type_creator = OpenStackVolumeType(
self.admin_os_creds, VolumeTypeConfig(name=self.volume_type_name))
self.volume_type_creator.create()
self.volume_creator = None
def tearDown(self):
if self.volume_creator:
self.volume_creator.clean()
if self.volume_type_creator:
self.volume_type_creator.clean()
super(self.__class__, self).__clean__()
def test_bad_volume_type(self):
"""
Expect a NotFound to be raised when the volume type does not exist
"""
self.volume_creator = OpenStackVolume(
self.os_creds, VolumeConfig(name=self.volume_name,
type_name='foo'))
with self.assertRaises(NotFound):
self.volume_creator.create()
def test_valid_volume_type(self):
"""
Expect a NotFound to be raised when the volume type does not exist
"""
self.volume_creator = OpenStackVolume(
self.admin_os_creds,
VolumeConfig(name=self.volume_name,
type_name=self.volume_type_name))
created_volume = self.volume_creator.create(block=True)
self.assertIsNotNone(created_volume)
self.assertEqual(self.volume_type_name, created_volume.type)
def test_create_two_vol_same_name_diff_proj(self):
"""
Creates a volume as admin to the project of os_creds then instantiates
a creator object with the os_creds project to ensure it initializes
without creation
"""
vol_name = self.guid + '-vol'
self.volume_creators.append(
OpenStackVolume(self.admin_os_creds, VolumeConfig(name=vol_name)))
admin_vol = self.volume_creators[0].create(block=True)
self.assertIsNotNone(admin_vol)
admin_key = keystone_utils.keystone_client(self.admin_os_creds,
self.admin_os_session)
admin_proj = keystone_utils.get_project(
admin_key, project_name=self.admin_os_creds.project_name)
self.assertEqual(admin_vol.project_id, admin_proj.id)
admin_cinder = cinder_utils.cinder_client(self.admin_os_creds,
self.admin_os_session)
admin_vol_get = cinder_utils.get_volume(
admin_cinder,
admin_key,
volume_name=vol_name,
project_name=self.admin_os_creds.project_name)
self.assertIsNotNone(admin_vol_get)
self.assertEqual(admin_vol, admin_vol_get)
self.volume_creators.append(
OpenStackVolume(self.os_creds, VolumeConfig(name=vol_name)))
proj_vol = self.volume_creators[1].create(block=True)
self.assertIsNotNone(proj_vol)
self.assertNotEqual(admin_vol, proj_vol)
proj_key = keystone_utils.keystone_client(self.os_creds,
self.os_session)
proj_cinder = cinder_utils.cinder_client(self.os_creds,
self.os_session)
proj_vol_get = cinder_utils.get_volume(
proj_cinder,
proj_key,
volume_name=vol_name,
project_name=self.os_creds.project_name)
self.assertIsNotNone(proj_vol_get)
self.assertEqual(proj_vol, proj_vol_get)
def test_valid_volume_image(self):
"""
Tests OpenStackVolume#create() method to ensure a volume is NOT created
when associating it to an invalid image name
"""
self.volume_creator = OpenStackVolume(
self.os_creds,
VolumeConfig(name=self.volume_name, image_name=self.image_name))
created_volume = self.volume_creator.create(block=True)
self.assertIsNotNone(created_volume)
self.assertEqual(self.volume_creator.volume_settings.name,
created_volume.name)
self.assertTrue(self.volume_creator.volume_active())
retrieved_volume = cinder_utils.get_volume_by_id(
self.cinder, created_volume.id)
self.assertEqual(created_volume, retrieved_volume)
def test_create_volume_simple(self):
"""
Tests the creation of a simple OpenStack volume.
"""
# Create Volume
self.volume_creator = OpenStackVolume(self.os_creds,
self.volume_settings)
created_volume = self.volume_creator.create(block=True)
self.assertIsNotNone(created_volume)
retrieved_volume = cinder_utils.get_volume(
self.cinder,
self.keystone,
volume_settings=self.volume_settings,
project_name=self.os_creds.project_name)
self.assertIsNotNone(retrieved_volume)
self.assertEqual(created_volume.id, retrieved_volume.id)
self.assertTrue(created_volume == retrieved_volume)
def test_create_same_volume(self):
"""
Tests the creation of an OpenStack volume when one already exists.
"""
# Create Volume
self.volume_creator = OpenStackVolume(self.os_creds,
self.volume_settings)
volume1 = self.volume_creator.create(block=True)
retrieved_volume = cinder_utils.get_volume(
self.cinder,
self.keystone,
volume_settings=self.volume_settings,
project_name=self.os_creds.project_name)
self.assertEqual(volume1, retrieved_volume)
# Should be retrieving the instance data
os_volume_2 = OpenStackVolume(self.os_creds, self.volume_settings)
volume2 = os_volume_2.create(block=True)
self.assertEqual(volume1, volume2)
def get_volume_creators(self):
"""
Returns a list of Volume creator objects as configured by the heat
template
:return: list() of OpenStackVolume objects
"""
out = list()
volumes = heat_utils.get_stack_volumes(self.__heat_cli, self.__cinder,
self.__stack)
for volume in volumes:
settings = settings_utils.create_volume_config(volume)
creator = OpenStackVolume(self._os_creds, settings)
out.append(creator)
try:
creator.initialize()
except Exception as e:
logger.error(
'Unexpected error initializing volume creator - %s', e)
return out
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 CreateSimpleVolumeFailureTests(OSIntegrationTestCase):
"""
Test for the CreateVolume class defined in create_volume.py
"""
def setUp(self):
"""
Instantiates the CreateVolume object that is responsible for
downloading and creating an OS volume file within OpenStack
"""
super(self.__class__, self).__start__()
self.guid = uuid.uuid4()
self.cinder = cinder_utils.cinder_client(self.os_creds,
self.os_session)
self.volume_creator = None
def tearDown(self):
"""
Cleans the volume and downloaded volume file
"""
if self.volume_creator:
self.volume_creator.clean()
super(self.__class__, self).__clean__()
def test_create_volume_bad_size(self):
"""
Tests the creation of an OpenStack volume with a negative size to
ensure it raises a BadRequest exception.
"""
volume_settings = VolumeConfig(name=self.__class__.__name__ + '-' +
str(self.guid),
size=-1)
# Create Volume
self.volume_creator = OpenStackVolume(self.os_creds, volume_settings)
with self.assertRaises(BadRequest):
self.volume_creator.create(block=True)
def test_create_volume_bad_type(self):
"""
Tests the creation of an OpenStack volume with a type that does not
exist to ensure it raises a NotFound exception.
"""
volume_settings = VolumeConfig(name=self.__class__.__name__ + '-' +
str(self.guid),
type_name='foo')
# Create Volume
self.volume_creator = OpenStackVolume(self.os_creds, volume_settings)
with self.assertRaises(NotFound):
self.volume_creator.create(block=True)
def test_create_volume_bad_image(self):
"""
Tests the creation of an OpenStack volume with an image that does not
exist to ensure it raises a BadRequest exception.
"""
volume_settings = VolumeConfig(name=self.__class__.__name__ + '-' +
str(self.guid),
image_name='foo')
# Create Volume
self.volume_creator = OpenStackVolume(self.os_creds, volume_settings)
with self.assertRaises(BadRequest):
self.volume_creator.create(block=True)
class CreateSimpleVolumeSuccessTests(OSIntegrationTestCase):
"""
Test for the CreateVolume class defined in create_volume.py
"""
def setUp(self):
"""
Instantiates the CreateVolume object that is responsible for
downloading and creating an OS volume file within OpenStack
"""
super(self.__class__, self).__start__()
guid = uuid.uuid4()
self.volume_settings = VolumeConfig(name=self.__class__.__name__ +
'-' + str(guid))
self.cinder = cinder_utils.cinder_client(self.os_creds,
self.os_session)
self.keystone = keystone_utils.keystone_client(self.os_creds,
self.os_session)
self.volume_creator = None
def tearDown(self):
"""
Cleans the volume and downloaded volume file
"""
if self.volume_creator:
self.volume_creator.clean()
super(self.__class__, self).__clean__()
def test_create_volume_simple(self):
"""
Tests the creation of a simple OpenStack volume.
"""
# Create Volume
self.volume_creator = OpenStackVolume(self.os_creds,
self.volume_settings)
created_volume = self.volume_creator.create(block=True)
self.assertIsNotNone(created_volume)
retrieved_volume = cinder_utils.get_volume(
self.cinder,
self.keystone,
volume_settings=self.volume_settings,
project_name=self.os_creds.project_name)
self.assertIsNotNone(retrieved_volume)
self.assertEqual(created_volume.id, retrieved_volume.id)
self.assertTrue(created_volume == retrieved_volume)
def test_create_delete_volume(self):
"""
Tests the creation then deletion of an OpenStack volume to ensure
clean() does not raise an Exception.
"""
# Create Volume
self.volume_creator = OpenStackVolume(self.os_creds,
self.volume_settings)
created_volume = self.volume_creator.create(block=True)
self.assertIsNotNone(created_volume)
retrieved_volume = cinder_utils.get_volume(
self.cinder,
self.keystone,
volume_settings=self.volume_settings,
project_name=self.os_creds.project_name)
self.assertIsNotNone(retrieved_volume)
self.assertEqual(created_volume, retrieved_volume)
# Delete Volume manually
self.volume_creator.clean()
self.assertIsNone(
cinder_utils.get_volume(self.cinder,
self.keystone,
volume_settings=self.volume_settings,
project_name=self.os_creds.project_name))
# Must not throw an exception when attempting to cleanup non-existent
# volume
self.volume_creator.clean()
self.assertIsNone(self.volume_creator.get_volume())
def test_create_same_volume(self):
"""
Tests the creation of an OpenStack volume when one already exists.
"""
# Create Volume
self.volume_creator = OpenStackVolume(self.os_creds,
self.volume_settings)
volume1 = self.volume_creator.create(block=True)
retrieved_volume = cinder_utils.get_volume(
self.cinder,
self.keystone,
volume_settings=self.volume_settings,
project_name=self.os_creds.project_name)
self.assertEqual(volume1, retrieved_volume)
# Should be retrieving the instance data
os_volume_2 = OpenStackVolume(self.os_creds, self.volume_settings)
volume2 = os_volume_2.create(block=True)
self.assertEqual(volume1, volume2)
class CreateVolumeWithImageTests(OSIntegrationTestCase):
"""
Test cases for the CreateVolume when attempting to associate it to an Image
"""
def setUp(self):
super(self.__class__, self).__start__()
self.cinder = cinder_utils.cinder_client(self.os_creds,
self.os_session)
guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
self.volume_name = guid + '-vol'
self.image_name = guid + '-image'
os_image_settings = openstack_tests.cirros_image_settings(
name=self.image_name, image_metadata=self.image_metadata)
# Create Image
self.image_creator = OpenStackImage(self.os_creds, os_image_settings)
self.image_creator.create()
self.volume_creator = None
def tearDown(self):
if self.volume_creator:
try:
self.volume_creator.clean()
except:
pass
if self.image_creator:
try:
self.image_creator.clean()
except:
pass
super(self.__class__, self).__clean__()
def test_bad_image_name(self):
"""
Tests OpenStackVolume#create() method to ensure a volume is NOT created
when associating it to an invalid image name
"""
self.volume_creator = OpenStackVolume(
self.os_creds, VolumeConfig(name=self.volume_name,
image_name='foo'))
with self.assertRaises(BadRequest):
self.volume_creator.create(block=True)
def test_valid_volume_image(self):
"""
Tests OpenStackVolume#create() method to ensure a volume is NOT created
when associating it to an invalid image name
"""
self.volume_creator = OpenStackVolume(
self.os_creds,
VolumeConfig(name=self.volume_name, image_name=self.image_name))
created_volume = self.volume_creator.create(block=True)
self.assertIsNotNone(created_volume)
self.assertEqual(self.volume_creator.volume_settings.name,
created_volume.name)
self.assertTrue(self.volume_creator.volume_active())
retrieved_volume = cinder_utils.get_volume_by_id(
self.cinder, created_volume.id)
self.assertEqual(created_volume, retrieved_volume)