1 ##############################################################################
2 # Copyright (c) 2016 Huawei Technologies Co.,Ltd and others.
4 # All rights reserved. This program and the accompanying materials
5 # are made available under the terms of the Apache License, Version 2.0
6 # which accompanies this distribution, and is available at
7 # http://www.apache.org/licenses/LICENSE-2.0
8 ##############################################################################
13 from oslo_utils import uuidutils
18 from yardstick.common import constants
19 from yardstick.common import openstack_utils
22 class GetCredentialsTestCase(unittest.TestCase):
24 @mock.patch('yardstick.common.openstack_utils.os')
25 def test_get_credentials(self, _):
26 with mock.patch.dict('os.environ', {'OS_IDENTITY_API_VERSION': '2'},
28 openstack_utils.get_credentials()
31 class GetHeatApiVersionTestCase(unittest.TestCase):
33 @mock.patch.object(openstack_utils, 'log')
34 def test_get_heat_api_version_check_result(self, *args):
35 API = 'HEAT_API_VERSION'
38 with mock.patch.dict(os.environ, {API: '2'}, clear=True):
39 api_version = openstack_utils.get_heat_api_version()
40 self.assertEqual(api_version, expected_result)
43 class GetShadeClientTestCase(unittest.TestCase):
45 @mock.patch.object(shade, 'openstack_cloud', return_value='os_client')
46 def test_get_shade_client(self, mock_openstack_cloud):
47 os_cloud_config = {'param1': True, 'param2': 'value2'}
48 self.assertEqual('os_client',
49 openstack_utils.get_shade_client(**os_cloud_config))
50 os_cloud_config.update(constants.OS_CLOUD_DEFAULT_CONFIG)
51 mock_openstack_cloud.assert_called_once_with(**os_cloud_config)
53 mock_openstack_cloud.reset_mock()
54 os_cloud_config = {'verify': True, 'param2': 'value2'}
55 self.assertEqual('os_client',
56 openstack_utils.get_shade_client(**os_cloud_config))
57 mock_openstack_cloud.assert_called_once_with(**os_cloud_config)
59 @mock.patch.object(shade, 'openstack_cloud', return_value='os_client')
60 def test_get_shade_client_no_parameters(self, mock_openstack_cloud):
61 self.assertEqual('os_client', openstack_utils.get_shade_client())
62 mock_openstack_cloud.assert_called_once_with(
63 **constants.OS_CLOUD_DEFAULT_CONFIG)
66 class DeleteNeutronNetTestCase(unittest.TestCase):
69 self.mock_shade_client = mock.Mock()
71 def test_delete_neutron_net(self):
72 self.mock_shade_client.delete_network.return_value = True
73 output = openstack_utils.delete_neutron_net(self.mock_shade_client,
75 self.assertTrue(output)
77 def test_delete_neutron_net_fail(self):
78 self.mock_shade_client.delete_network.return_value = False
79 output = openstack_utils.delete_neutron_net(self.mock_shade_client,
81 self.assertFalse(output)
83 @mock.patch.object(openstack_utils, 'log')
84 def test_delete_neutron_net_exception(self, mock_logger):
85 self.mock_shade_client.delete_network.side_effect = (
86 exc.OpenStackCloudException('error message'))
87 output = openstack_utils.delete_neutron_net(self.mock_shade_client,
89 self.assertFalse(output)
90 mock_logger.error.assert_called_once()
93 class CreateNeutronNetTestCase(unittest.TestCase):
96 self.mock_shade_client = mock.Mock()
97 self.network_name = 'name'
98 self.mock_shade_client.create_network = mock.Mock()
100 def test_create_neutron_net(self):
101 _uuid = uuidutils.generate_uuid()
102 self.mock_shade_client.create_network.return_value = {'id': _uuid}
103 output = openstack_utils.create_neutron_net(self.mock_shade_client,
105 self.assertEqual(_uuid, output)
107 @mock.patch.object(openstack_utils, 'log')
108 def test_create_neutron_net_exception(self, mock_logger):
109 self.mock_shade_client.create_network.side_effect = (
110 exc.OpenStackCloudException('error message'))
112 output = openstack_utils.create_neutron_net(self.mock_shade_client,
114 mock_logger.error.assert_called_once()
115 self.assertIsNone(output)
118 class CreateNeutronSubnetTestCase(unittest.TestCase):
121 self.mock_shade_client = mock.Mock()
122 self.network_name_or_id = 'name_or_id'
123 self.mock_shade_client.create_subnet = mock.Mock()
125 def test_create_neutron_subnet(self):
126 _uuid = uuidutils.generate_uuid()
127 self.mock_shade_client.create_subnet.return_value = {'id': _uuid}
128 output = openstack_utils.create_neutron_subnet(
129 self.mock_shade_client, self.network_name_or_id)
130 self.assertEqual(_uuid, output)
132 @mock.patch.object(openstack_utils, 'log')
133 def test_create_neutron_subnet_exception(self, mock_logger):
134 self.mock_shade_client.create_subnet.side_effect = (
135 exc.OpenStackCloudException('error message'))
137 output = openstack_utils.create_neutron_subnet(
138 self.mock_shade_client, self.network_name_or_id)
139 mock_logger.error.assert_called_once()
140 self.assertIsNone(output)
143 class DeleteNeutronRouterTestCase(unittest.TestCase):
146 self.mock_shade_client = mock.Mock()
147 self.mock_shade_client.delete_router = mock.Mock()
149 def test_delete_neutron_router(self):
150 self.mock_shade_client.delete_router.return_value = True
151 output = openstack_utils.delete_neutron_router(self.mock_shade_client,
153 self.assertTrue(output)
155 def test_delete_neutron_router_fail(self):
156 self.mock_shade_client.delete_router.return_value = False
157 output = openstack_utils.delete_neutron_router(self.mock_shade_client,
159 self.assertFalse(output)
161 @mock.patch.object(openstack_utils, 'log')
162 def test_delete_neutron_router_exception(self, mock_logger):
163 self.mock_shade_client.delete_router.side_effect = (
164 exc.OpenStackCloudException('error message'))
165 output = openstack_utils.delete_neutron_router(self.mock_shade_client,
167 mock_logger.error.assert_called_once()
168 self.assertFalse(output)
171 class CreateNeutronRouterTestCase(unittest.TestCase):
174 self.mock_shade_client = mock.Mock()
175 self.mock_shade_client.create_subnet = mock.Mock()
177 def test_create_neutron_router(self):
178 _uuid = uuidutils.generate_uuid()
179 self.mock_shade_client.create_router.return_value = {'id': _uuid}
180 output = openstack_utils.create_neutron_router(
181 self.mock_shade_client)
182 self.assertEqual(_uuid, output)
184 @mock.patch.object(openstack_utils, 'log')
185 def test_create_neutron_subnet_exception(self, mock_logger):
186 self.mock_shade_client.create_router.side_effect = (
187 exc.OpenStackCloudException('error message'))
189 output = openstack_utils.create_neutron_router(
190 self.mock_shade_client)
191 mock_logger.error.assert_called_once()
192 self.assertIsNone(output)
195 class RemoveRouterInterfaceTestCase(unittest.TestCase):
198 self.mock_shade_client = mock.Mock()
199 self.router = 'router'
200 self.mock_shade_client.remove_router_interface = mock.Mock()
202 def test_remove_router_interface(self):
203 self.mock_shade_client.remove_router_interface.return_value = True
204 output = openstack_utils.remove_router_interface(
205 self.mock_shade_client, self.router)
206 self.assertTrue(output)
208 @mock.patch.object(openstack_utils, 'log')
209 def test_remove_router_interface_exception(self, mock_logger):
210 self.mock_shade_client.remove_router_interface.side_effect = (
211 exc.OpenStackCloudException('error message'))
212 output = openstack_utils.remove_router_interface(
213 self.mock_shade_client, self.router)
214 mock_logger.error.assert_called_once()
215 self.assertFalse(output)
218 class CreateFloatingIpTestCase(unittest.TestCase):
221 self.mock_shade_client = mock.Mock()
222 self.network_name_or_id = 'name'
223 self.mock_shade_client.create_floating_ip = mock.Mock()
225 def test_create_floating_ip(self):
226 self.mock_shade_client.create_floating_ip.return_value = \
227 {'floating_ip_address': 'value1', 'id': 'value2'}
228 output = openstack_utils.create_floating_ip(self.mock_shade_client,
229 self.network_name_or_id)
230 self.assertEqual({'fip_addr': 'value1', 'fip_id': 'value2'}, output)
232 @mock.patch.object(openstack_utils, 'log')
233 def test_create_floating_ip_exception(self, mock_logger):
234 self.mock_shade_client.create_floating_ip.side_effect = (
235 exc.OpenStackCloudException('error message'))
236 output = openstack_utils.create_floating_ip(
237 self.mock_shade_client, self.network_name_or_id)
238 mock_logger.error.assert_called_once()
239 self.assertIsNone(output)
242 class DeleteFloatingIpTestCase(unittest.TestCase):
245 self.mock_shade_client = mock.Mock()
246 self.floating_ip_id = 'floating_ip_id'
247 self.mock_shade_client.delete_floating_ip = mock.Mock()
249 def test_delete_floating_ip(self):
250 self.mock_shade_client.delete_floating_ip.return_value = True
251 output = openstack_utils.delete_floating_ip(self.mock_shade_client,
253 self.assertTrue(output)
255 def test_delete_floating_ip_fail(self):
256 self.mock_shade_client.delete_floating_ip.return_value = False
257 output = openstack_utils.delete_floating_ip(self.mock_shade_client,
259 self.assertFalse(output)
261 @mock.patch.object(openstack_utils, 'log')
262 def test_delete_floating_ip_exception(self, mock_logger):
263 self.mock_shade_client.delete_floating_ip.side_effect = (
264 exc.OpenStackCloudException('error message'))
265 output = openstack_utils.delete_floating_ip(self.mock_shade_client,
267 mock_logger.error.assert_called_once()
268 self.assertFalse(output)
271 class CreateSecurityGroupRuleTestCase(unittest.TestCase):
274 self.mock_shade_client = mock.Mock()
275 self.secgroup_name_or_id = 'sg_name_id'
276 self.mock_shade_client.create_security_group_rule = mock.Mock()
277 self._mock_log = mock.patch.object(openstack_utils, 'log')
278 self.mock_log = self._mock_log.start()
279 self.addCleanup(self._stop_mock)
281 def _stop_mock(self):
282 self._mock_log.stop()
284 def test_create_security_group_rule(self):
285 self.mock_shade_client.create_security_group_rule.return_value = (
286 {'security_group_rule'})
287 output = openstack_utils.create_security_group_rule(
288 self.mock_shade_client, self.secgroup_name_or_id)
289 self.assertTrue(output)
291 def test_create_security_group_rule_exception(self):
292 self.mock_shade_client.create_security_group_rule.side_effect = (
293 exc.OpenStackCloudException('error message'))
295 output = openstack_utils.create_security_group_rule(
296 self.mock_shade_client, self.secgroup_name_or_id)
297 self.mock_log.error.assert_called_once()
298 self.assertFalse(output)
301 class ListImageTestCase(unittest.TestCase):
303 def test_list_images(self):
304 mock_shade_client = mock.MagicMock()
305 mock_shade_client.list_images.return_value = []
306 openstack_utils.list_images(mock_shade_client)
308 @mock.patch.object(openstack_utils, 'log')
309 def test_list_images_exception(self, mock_logger):
310 mock_shade_client = mock.MagicMock()
311 mock_shade_client.list_images = mock.MagicMock()
312 mock_shade_client.list_images.side_effect = (
313 exc.OpenStackCloudException('error message'))
314 images = openstack_utils.list_images(mock_shade_client)
315 mock_logger.error.assert_called_once()
316 self.assertFalse(images)
319 class SecurityGroupTestCase(unittest.TestCase):
322 self.mock_shade_client = mock.Mock()
323 self.sg_name = 'sg_name'
324 self.sg_description = 'sg_description'
325 self._uuid = uuidutils.generate_uuid()
326 self._mock_log = mock.patch.object(openstack_utils, 'log')
327 self.mock_log = self._mock_log.start()
328 self.addCleanup(self._stop_mock)
330 def _stop_mock(self):
331 self._mock_log.stop()
333 def test_create_security_group_full_existing_security_group(self):
334 self.mock_shade_client.get_security_group.return_value = (
335 {'name': 'name', 'id': self._uuid})
336 output = openstack_utils.create_security_group_full(
337 self.mock_shade_client, self.sg_name, self.sg_description)
338 self.mock_shade_client.get_security_group.assert_called_once()
339 self.assertEqual(self._uuid, output)
341 def test_create_security_group_full_non_existing_security_group(self):
342 self.mock_shade_client.get_security_group.return_value = None
343 self.mock_shade_client.create_security_group.side_effect = (
344 exc.OpenStackCloudException('error message'))
345 output = openstack_utils.create_security_group_full(
346 self.mock_shade_client, self.sg_name, self.sg_description)
347 self.mock_log.error.assert_called_once()
348 self.assertIsNone(output)
350 @mock.patch.object(openstack_utils, 'create_security_group_rule')
351 def test_create_security_group_full_create_rule_fail(
352 self, mock_create_security_group_rule):
353 self.mock_shade_client.get_security_group.return_value = None
354 self.mock_shade_client.create_security_group.return_value = (
355 {'name': 'name', 'id': self._uuid})
356 mock_create_security_group_rule.return_value = False
357 output = openstack_utils.create_security_group_full(
358 self.mock_shade_client, self.sg_name, self.sg_description)
359 mock_create_security_group_rule.assert_called()
360 self.mock_shade_client.delete_security_group(self.sg_name)
361 self.mock_log.error.assert_called_once()
362 self.assertIsNone(output)
364 @mock.patch.object(openstack_utils, 'create_security_group_rule')
365 def test_create_security_group_full(
366 self, mock_create_security_group_rule):
367 self.mock_shade_client.get_security_group.return_value = None
368 self.mock_shade_client.create_security_group.return_value = (
369 {'name': 'name', 'id': self._uuid})
370 mock_create_security_group_rule.return_value = True
371 output = openstack_utils.create_security_group_full(
372 self.mock_shade_client, self.sg_name, self.sg_description)
373 mock_create_security_group_rule.assert_called()
374 self.mock_shade_client.delete_security_group(self.sg_name)
375 self.assertEqual(self._uuid, output)
378 class CreateInstanceTestCase(unittest.TestCase):
380 def test_create_instance_and_wait_for_active(self):
381 self.mock_shade_client = mock.Mock()
384 flavor = 'flavor_name'
385 self.mock_shade_client.create_server.return_value = (
386 {'name': name, 'image': image, 'flavor': flavor})
387 output = openstack_utils.create_instance_and_wait_for_active(
388 self.mock_shade_client, name, image, flavor)
390 {'name': name, 'image': image, 'flavor': flavor}, output)
392 @mock.patch.object(openstack_utils, 'log')
393 def test_create_instance_and_wait_for_active_fail(self, mock_logger):
394 self.mock_shade_client = mock.Mock()
395 self.mock_shade_client.create_server.side_effect = (
396 exc.OpenStackCloudException('error message'))
397 output = openstack_utils.create_instance_and_wait_for_active(
398 self.mock_shade_client, 'server_name', 'image_name', 'flavor_name')
399 mock_logger.error.assert_called_once()
400 self.assertIsNone(output)
403 class DeleteInstanceTestCase(unittest.TestCase):
406 self.mock_shade_client = mock.Mock()
408 def test_delete_instance(self):
409 self.mock_shade_client.delete_server.return_value = True
410 output = openstack_utils.delete_instance(self.mock_shade_client,
412 self.assertTrue(output)
414 def test_delete_instance_fail(self):
415 self.mock_shade_client.delete_server.return_value = False
416 output = openstack_utils.delete_instance(self.mock_shade_client,
418 self.assertFalse(output)
420 @mock.patch.object(openstack_utils, 'log')
421 def test_delete_instance_exception(self, mock_logger):
422 self.mock_shade_client.delete_server.side_effect = (
423 exc.OpenStackCloudException('error message'))
424 output = openstack_utils.delete_instance(self.mock_shade_client,
426 mock_logger.error.assert_called_once()
427 self.assertFalse(output)
430 class CreateKeypairTestCase(unittest.TestCase):
433 self.mock_shade_client = mock.Mock()
434 self.name = 'key_name'
436 def test_create_keypair(self):
437 self.mock_shade_client.create_keypair.return_value = (
438 {'name': 'key-name', 'type': 'ssh'})
439 output = openstack_utils.create_keypair(
440 self.mock_shade_client, self.name)
442 {'name': 'key-name', 'type': 'ssh'},
445 @mock.patch.object(openstack_utils, 'log')
446 def test_create_keypair_fail(self, mock_logger):
447 self.mock_shade_client.create_keypair.side_effect = (
448 exc.OpenStackCloudException('error message'))
449 output = openstack_utils.create_keypair(
450 self.mock_shade_client, self.name)
451 mock_logger.error.assert_called_once()
452 self.assertIsNone(output)
455 class DeleteKeypairTestCase(unittest.TestCase):
458 self.mock_shade_client = mock.Mock()
460 def test_delete_keypair(self):
461 self.mock_shade_client.delete_keypair.return_value = True
462 output = openstack_utils.delete_keypair(self.mock_shade_client,
464 self.assertTrue(output)
466 def test_delete_keypair_fail(self):
467 self.mock_shade_client.delete_keypair.return_value = False
468 output = openstack_utils.delete_keypair(self.mock_shade_client,
470 self.assertFalse(output)
472 @mock.patch.object(openstack_utils, 'log')
473 def test_delete_keypair_exception(self, mock_logger):
474 self.mock_shade_client.delete_keypair.side_effect = (
475 exc.OpenStackCloudException('error message'))
476 output = openstack_utils.delete_keypair(self.mock_shade_client,
478 mock_logger.error.assert_called_once()
479 self.assertFalse(output)
482 class AttachVolumeToServerTestCase(unittest.TestCase):
484 def test_attach_volume_to_server(self):
485 self.mock_shade_client = mock.Mock()
486 self.mock_shade_client.get_server.return_value = {'server_dict'}
487 self.mock_shade_client.get_volume.return_value = {'volume_dict'}
488 self.mock_shade_client.attach_volume.return_value = True
489 output = openstack_utils.attach_volume_to_server(
490 self.mock_shade_client, 'server_name_or_id', 'volume_name_or_id')
491 self.assertTrue(output)
493 @mock.patch.object(openstack_utils, 'log')
494 def test_attach_volume_to_server_fail(self, mock_logger):
495 self.mock_shade_client = mock.Mock()
496 self.mock_shade_client.attach_volume.side_effect = (
497 exc.OpenStackCloudException('error message'))
498 output = openstack_utils.attach_volume_to_server(
499 self.mock_shade_client, 'server_name_or_id', 'volume_name_or_id')
500 mock_logger.error.assert_called_once()
501 self.assertFalse(output)
504 class GetServerTestCase(unittest.TestCase):
506 def test_get_server(self):
507 self.mock_shade_client = mock.Mock()
508 _uuid = uuidutils.generate_uuid()
509 self.mock_shade_client.get_server.return_value = {
510 'name': 'server_name', 'id': _uuid}
511 output = openstack_utils.get_server(self.mock_shade_client,
513 self.assertEqual({'name': 'server_name', 'id': _uuid}, output)
515 @mock.patch.object(openstack_utils, 'log')
516 def test_get_server_exception(self, mock_logger):
517 self.mock_shade_client = mock.Mock()
518 self.mock_shade_client.get_server.side_effect = (
519 exc.OpenStackCloudException('error message'))
520 output = openstack_utils.get_server(self.mock_shade_client,
522 mock_logger.error.assert_called_once()
523 self.assertIsNone(output)
526 class GetFlavorTestCase(unittest.TestCase):
528 def test_get_flavor(self):
529 self.mock_shade_client = mock.Mock()
530 _uuid = uuidutils.generate_uuid()
531 self.mock_shade_client.get_flavor.return_value = {
532 'name': 'flavor_name', 'id': _uuid}
533 output = openstack_utils.get_flavor(self.mock_shade_client,
535 self.assertEqual({'name': 'flavor_name', 'id': _uuid}, output)
537 @mock.patch.object(openstack_utils, 'log')
538 def test_get_flavor_exception(self, mock_logger):
539 self.mock_shade_client = mock.Mock()
540 self.mock_shade_client.get_flavor.side_effect = (
541 exc.OpenStackCloudException('error message'))
542 output = openstack_utils.get_flavor(self.mock_shade_client,
544 mock_logger.error.assert_called_once()
545 self.assertIsNone(output)
548 class GetVolumeIDTestCase(unittest.TestCase):
550 def test_get_volume_id(self):
551 self.mock_shade_client = mock.Mock()
552 _uuid = uuidutils.generate_uuid()
553 self.mock_shade_client.get_volume_id.return_value = _uuid
554 output = openstack_utils.get_volume_id(self.mock_shade_client,
556 self.assertEqual(_uuid, output)
558 def test_get_volume_id_None(self):
559 self.mock_shade_client = mock.Mock()
560 self.mock_shade_client.get_volume_id.return_value = None
561 output = openstack_utils.get_volume_id(self.mock_shade_client,
563 self.assertIsNone(output)
566 class GetVolumeTestCase(unittest.TestCase):
569 self.mock_shade_client = mock.Mock()
570 self.mock_shade_client.get_volume = mock.Mock()
572 def test_get_volume(self):
573 self.mock_shade_client.get_volume.return_value = {'volume'}
574 output = openstack_utils.get_volume(self.mock_shade_client,
576 self.assertEqual({'volume'}, output)
578 def test_get_volume_None(self):
579 self.mock_shade_client.get_volume.return_value = None
580 output = openstack_utils.get_volume(self.mock_shade_client,
582 self.assertIsNone(output)
585 class CreateVolumeTestCase(unittest.TestCase):
588 self.mock_shade_client = mock.Mock()
591 def test_create_volume(self):
592 self.mock_shade_client.create_volume.return_value = (
593 {'name': 'volume-name', 'size': self.size})
594 output = openstack_utils.create_volume(
595 self.mock_shade_client, self.size)
597 {'name': 'volume-name', 'size': self.size},
600 @mock.patch.object(openstack_utils, 'log')
601 def test_create_volume_fail(self, mock_logger):
602 self.mock_shade_client.create_volume.side_effect = (
603 exc.OpenStackCloudException('error message'))
604 output = openstack_utils.create_volume(self.mock_shade_client,
606 mock_logger.error.assert_called_once()
607 self.assertIsNone(output)
610 class DeleteVolumeTestCase(unittest.TestCase):
613 self.mock_shade_client = mock.Mock()
615 def test_delete_volume(self):
616 self.mock_shade_client.delete_volume.return_value = True
617 output = openstack_utils.delete_volume(self.mock_shade_client,
619 self.assertTrue(output)
621 def test_delete_volume_fail(self):
622 self.mock_shade_client.delete_volume.return_value = False
623 output = openstack_utils.delete_volume(self.mock_shade_client,
625 self.assertFalse(output)
627 @mock.patch.object(openstack_utils, 'log')
628 def test_delete_volume_exception(self, mock_logger):
629 self.mock_shade_client.delete_volume.side_effect = (
630 exc.OpenStackCloudException('error message'))
631 output = openstack_utils.delete_volume(self.mock_shade_client,
633 mock_logger.error.assert_called_once()
634 self.assertFalse(output)
637 class DetachVolumeTestCase(unittest.TestCase):
639 @mock.patch.object(openstack_utils, 'get_server')
640 def test_detach_volume(self, mock_get_server):
641 self.mock_shade_client = mock.Mock()
642 mock_get_server.return_value = {'server_dict'}
643 self.mock_shade_client.get_volume.return_value = {'volume_dict'}
644 output = openstack_utils.detach_volume(self.mock_shade_client,
647 self.assertTrue(output)
649 @mock.patch.object(openstack_utils, 'get_server')
650 @mock.patch.object(openstack_utils, 'log')
651 def test_detach_volume_exception(self, mock_logger, mock_get_server):
652 self.mock_shade_client = mock.Mock()
653 mock_get_server.return_value = {'server_dict'}
654 self.mock_shade_client.get_volume.return_value = {'volume_dict'}
655 self.mock_shade_client.detach_volume.side_effect = (
656 exc.OpenStackCloudException('error message'))
657 output = openstack_utils.detach_volume(self.mock_shade_client,
660 mock_logger.error.assert_called_once()
661 self.assertFalse(output)
664 class CreateImageTestCase(unittest.TestCase):
667 self.mock_shade_client = mock.Mock()
668 self._uuid = uuidutils.generate_uuid()
669 self.name = 'image_name'
670 self._mock_log = mock.patch.object(openstack_utils, 'log')
671 self.mock_log = self._mock_log.start()
672 self.addCleanup(self._stop_mock)
674 def _stop_mock(self):
675 self._mock_log.stop()
677 def test_create_image_already_exit(self):
678 self.mock_shade_client.get_image_id.return_value = self._uuid
679 output = openstack_utils.create_image(self.mock_shade_client, self.name)
680 self.mock_log.info.assert_called_once()
681 self.assertEqual(self._uuid, output)
683 def test_create_image(self):
684 self.mock_shade_client.get_image_id.return_value = None
685 self.mock_shade_client.create_image.return_value = {'id': self._uuid}
686 output = openstack_utils.create_image(self.mock_shade_client, self.name)
687 self.assertEqual(self._uuid, output)
689 def test_create_image_exception(self):
690 self.mock_shade_client.get_image_id.return_value = None
691 self.mock_shade_client.create_image.side_effect = (
692 exc.OpenStackCloudException('error message'))
694 output = openstack_utils.create_image(self.mock_shade_client,
696 self.mock_log.error.assert_called_once()
697 self.assertIsNone(output)
700 class DeleteImageTestCase(unittest.TestCase):
702 def test_delete_image(self):
703 self.mock_shade_client = mock.Mock()
704 self.mock_shade_client.delete_image.return_value = True
705 output = openstack_utils.delete_image(self.mock_shade_client,
707 self.assertTrue(output)
709 def test_delete_image_fail(self):
710 self.mock_shade_client = mock.Mock()
711 self.mock_shade_client.delete_image.return_value = False
712 output = openstack_utils.delete_image(self.mock_shade_client,
714 self.assertFalse(output)
716 @mock.patch.object(openstack_utils, 'log')
717 def test_delete_image_exception(self, mock_logger):
718 self.mock_shade_client = mock.Mock()
719 self.mock_shade_client.delete_image.side_effect = (
720 exc.OpenStackCloudException('error message'))
721 output = openstack_utils.delete_image(self.mock_shade_client,
723 mock_logger.error.assert_called_once()
724 self.assertFalse(output)