def test_create_instance(self, mock_glance, mock_cinder, mock_neutron,
mock_nova):
nova_util = nova_helper.NovaHelper()
instance = self.fake_server(self.instance_uuid)
nova_util.nova.servers.create.return_value = instance
nova_util.nova.servers.get.return_value = instance
create_instance = nova_util.create_instance(self.source_node)
self.assertIsNotNone(create_instance)
self.assertEqual(create_instance, instance)
# verify that the method create_instance will return None when
# the method findall raises exception.
nova_util.nova.keypairs.findall.side_effect = nvexceptions.NotFound(
404)
instance = nova_util.create_instance(self.source_node)
self.assertIsNone(instance)
nova_util.nova.keypairs.findall.side_effect = None
# verify that the method create_instance will return None when
# the method get raises exception.
nova_util.glance.images.get.side_effect = glexceptions.NotFound(404)
instance = nova_util.create_instance(self.source_node)
self.assertIsNone(instance)
nova_util.glance.images.get.side_effect = None
# verify that the method create_instance will return None when
# the method find raises exception.
nova_util.nova.flavors.find.side_effect = nvexceptions.NotFound(404)
instance = nova_util.create_instance(self.source_node)
self.assertIsNone(instance)
nova_util.nova.flavors.find.side_effect = None
# verify that the method create_instance will return None when
# the method get_security_group_id_from_name return None.
with mock.patch.object(nova_util,
'get_security_group_id_from_name',
return_value=None) as mock_security_group_id:
instance = nova_util.create_instance(self.source_node)
self.assertIsNone(instance)
mock_security_group_id.assert_called_once_with("default")
# verify that the method create_instance will return None when
# the method get_network_id_from_name return None.
with mock.patch.object(nova_util,
'get_network_id_from_name',
return_value=None) as mock_get_network_id:
instance = nova_util.create_instance(self.source_node)
self.assertIsNone(instance)
mock_get_network_id.assert_called_once_with("demo-net")
# verify that the method create_instance will not return None when
# the method wait_for_instance_status return True.
with mock.patch.object(nova_util,
'wait_for_instance_status',
return_value=True) as mock_instance_status:
instance = nova_util.create_instance(self.source_node)
self.assertIsNotNone(instance)
mock_instance_status.assert_called_once_with(
mock.ANY, ('ACTIVE', 'ERROR'), 5, 10)
def update(self, image_id, **metadata):
for i, image in enumerate(self._images):
if image.id == str(image_id):
for k, v in metadata.items():
setattr(self._images[i], k, v)
return self._images[i]
raise glance_exc.NotFound(image_id)
def delete(self, image_id):
for i, image in enumerate(self._images):
if image.id == image_id:
# When you delete an image from glance, it sets the status to
# DELETED. If you try to delete a DELETED image, it raises
# HTTPForbidden.
image_data = self._images[i]
if image_data.deleted:
raise glance_exc.Forbidden()
image_data.deleted = True
return
raise glance_exc.NotFound(image_id)
def test_instance_create_image_id_err(self):
stack_name = 'test_instance_create_image_id_err_stack'
(t, stack) = self._setup_test_stack(stack_name)
# create an instance with non exist image Id
t['Resources']['WebServer']['Properties']['ImageId'] = '1'
instance = instances.Instance('instance_create_image_err',
t['Resources']['WebServer'], stack)
self._mock_get_image_id_fail('1', glance_exceptions.NotFound(404))
self.m.ReplayAll()
self.assertRaises(ValueError, instance.handle_create)
self.m.VerifyAll()
def image_verify(self, image_id):
"""
Verifies if image with image-id exists and is in active state
Arguments:
image_id(string): UUID of the image
Returns:
None
Raises except if image not found or not in active state
"""
img = self.image_get(image_id)
if img['status'] != 'active':
raise GlanceException.NotFound(
"Image with image_id: %s not found in active state. Current State: %s"
% (img['id'], img['status']))
def test_get_image_id_not_found(self):
"""Tests the get_image_id function while image is not found."""
my_image = self.m.CreateMockAnything()
img_name = str(uuid.uuid4())
my_image.name = img_name
self.glance_client.images = self.m.CreateMockAnything()
self.glance_client.images.get(img_name).AndRaise(
glance_exceptions.NotFound(404))
filters = {'name': img_name}
self.glance_client.images.list(filters=filters).MultipleTimes().\
AndReturn([])
self.m.ReplayAll()
self.assertRaises(exception.ImageNotFound, glance_utils.get_image_id,
self.glance_client, img_name)
self.m.VerifyAll()
def test_get_image_id_by_name_in_uuid(self):
"""Tests the get_image_id function by name in uuid."""
my_image = self.m.CreateMockAnything()
img_id = str(uuid.uuid4())
img_name = str(uuid.uuid4())
my_image.id = img_id
my_image.name = img_name
self.glance_client.images = self.m.CreateMockAnything()
self.glance_client.images.get(img_name).AndRaise(
glance_exceptions.NotFound(404))
filters = {'name': img_name}
self.glance_client.images.list(filters=filters).MultipleTimes().\
AndReturn([my_image])
self.m.ReplayAll()
self.assertEqual(
img_id, glance_utils.get_image_id(self.glance_client, img_name))
self.m.VerifyAll()
def _upload_file(glanceclient,
name,
path,
disk_format,
type_name,
skip_missing=False):
image_tuple = collections.namedtuple('image', ['id'])
try:
if isinstance(glanceclient, real_glance_client):
images = glanceclient.images.list(name=name,
disk_format=disk_format)
image = None
for img in images:
if ((img['name'] == name or img['id'] == name)
and img['disk_format'] == disk_format):
image = img
if not image:
raise exceptions.NotFound("No image found")
else:
# TODO(dprince) remove this
# This code expects the python-openstackclient version of
# "glanceclient" (which isn't pure python-glanceclient) and is
# here for backwards compat until python-tripleoclient starts
# using the Mistral API for this functionality.
image = glanceclient.images.find(name=name,
disk_format=disk_format)
except exceptions.NotFound:
if path:
image = glanceclient.images.create(name=name,
disk_format=disk_format,
is_public=True,
data=open(path, 'rb'))
else:
if skip_missing:
image = image_tuple(None)
else:
raise ValueError("%s image not found in Glance, and no path "
"specified." % type_name)
return image
def test_instance_create_image_id_err(self):
stack_name = 'test_instance_create_image_id_err_stack'
(tmpl, stack) = self._setup_test_stack(stack_name)
# create an instance with non exist image Id
tmpl.t['Resources']['WebServer']['Properties']['ImageId'] = '1'
resource_defns = tmpl.resource_definitions(stack)
instance = instances.Instance('instance_create_image_err',
resource_defns['WebServer'], stack)
self._mock_get_image_id_fail('1', glance_exceptions.NotFound(404))
self.m.ReplayAll()
create = scheduler.TaskRunner(instance.create)
error = self.assertRaises(exception.ResourceFailure, create)
self.assertEqual(
'StackValidationFailed: Property error : WebServer: '
'ImageId 404 (HTTP 404)',
str(error))
self.m.VerifyAll()
def get(self, image_id):
raise glance_exc.NotFound(image_id)
def get(self, image_id):
for image in self._images:
if image.id == str(image_id):
return image
raise glance_exc.NotFound(image_id)
