yardstick/tests/unit/common/test_openstack_utils.py

   1 ##############################################################################
   2 # Copyright (c) 2016 Huawei Technologies Co.,Ltd and others.
   3 #
   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 ##############################################################################
   9
  10 from oslo_utils import uuidutils
  11 import unittest
  12 import mock
  13 import shade
  14 from shade import exc
  15
  16 from yardstick.common import constants
  17 from yardstick.common import openstack_utils
  18
  19
  20 class GetCredentialsTestCase(unittest.TestCase):
  21
  22     @mock.patch('yardstick.common.openstack_utils.os')
  23     def test_get_credentials(self, _):
  24         with mock.patch.dict('os.environ', {'OS_IDENTITY_API_VERSION': '2'},
  25                              clear=True):
  26             openstack_utils.get_credentials()
  27
  28
  29 class GetHeatApiVersionTestCase(unittest.TestCase):
  30
  31     def test_get_heat_api_version_check_result(self):
  32         API = 'HEAT_API_VERSION'
  33         expected_result = '2'
  34
  35         with mock.patch.dict('os.environ', {API: '2'}, clear=True):
  36             api_version = openstack_utils.get_heat_api_version()
  37             self.assertEqual(api_version, expected_result)
  38
  39
  40 class GetShadeClientTestCase(unittest.TestCase):
  41
  42     @mock.patch.object(shade, 'openstack_cloud', return_value='os_client')
  43     def test_get_shade_client(self, mock_openstack_cloud):
  44         os_cloud_config = {'param1': True, 'param2': 'value2'}
  45         self.assertEqual('os_client',
  46                          openstack_utils.get_shade_client(**os_cloud_config))
  47         os_cloud_config.update(constants.OS_CLOUD_DEFAULT_CONFIG)
  48         mock_openstack_cloud.assert_called_once_with(**os_cloud_config)
  49
  50         mock_openstack_cloud.reset_mock()
  51         os_cloud_config = {'verify': True, 'param2': 'value2'}
  52         self.assertEqual('os_client',
  53                          openstack_utils.get_shade_client(**os_cloud_config))
  54         mock_openstack_cloud.assert_called_once_with(**os_cloud_config)
  55
  56     @mock.patch.object(shade, 'openstack_cloud', return_value='os_client')
  57     def test_get_shade_client_no_parameters(self, mock_openstack_cloud):
  58         self.assertEqual('os_client', openstack_utils.get_shade_client())
  59         mock_openstack_cloud.assert_called_once_with(
  60             **constants.OS_CLOUD_DEFAULT_CONFIG)
  61
  62     @mock.patch.object(shade, 'operator_cloud', return_value='os_client')
  63     def test_get_shade_operator_client(self, mock_operator_cloud):
  64         self.assertEqual('os_client', openstack_utils.get_shade_operator_client())
  65         mock_operator_cloud.assert_called_once_with(
  66             **constants.OS_CLOUD_DEFAULT_CONFIG)
  67
  68
  69 class DeleteNeutronNetTestCase(unittest.TestCase):
  70
  71     def setUp(self):
  72         self.mock_shade_client = mock.Mock()
  73
  74     def test_delete_neutron_net(self):
  75         self.mock_shade_client.delete_network.return_value = True
  76         output = openstack_utils.delete_neutron_net(self.mock_shade_client,
  77                                                     'network_name_or_id')
  78         self.assertTrue(output)
  79
  80     def test_delete_neutron_net_fail(self):
  81         self.mock_shade_client.delete_network.return_value = False
  82         output = openstack_utils.delete_neutron_net(self.mock_shade_client,
  83                                                     'network_name_or_id')
  84         self.assertFalse(output)
  85
  86     @mock.patch.object(openstack_utils, 'log')
  87     def test_delete_neutron_net_exception(self, mock_logger):
  88         self.mock_shade_client.delete_network.side_effect = (
  89             exc.OpenStackCloudException('error message'))
  90         output = openstack_utils.delete_neutron_net(self.mock_shade_client,
  91                                                     'network_name_or_id')
  92         self.assertFalse(output)
  93         mock_logger.error.assert_called_once()
  94
  95
  96 class CreateNeutronNetTestCase(unittest.TestCase):
  97
  98     def setUp(self):
  99         self.mock_shade_client = mock.Mock()
 100         self.network_name = 'name'
 101         self.mock_shade_client.create_network = mock.Mock()
 102
 103     def test_create_neutron_net(self):
 104         _uuid = uuidutils.generate_uuid()
 105         self.mock_shade_client.create_network.return_value = {'id': _uuid}
 106         output = openstack_utils.create_neutron_net(self.mock_shade_client,
 107                                                     self.network_name)
 108         self.assertEqual(_uuid, output)
 109
 110     @mock.patch.object(openstack_utils, 'log')
 111     def test_create_neutron_net_exception(self, mock_logger):
 112         self.mock_shade_client.create_network.side_effect = (
 113             exc.OpenStackCloudException('error message'))
 114
 115         output = openstack_utils.create_neutron_net(self.mock_shade_client,
 116                                                     self.network_name)
 117         mock_logger.error.assert_called_once()
 118         self.assertIsNone(output)
 119
 120
 121 class CreateNeutronSubnetTestCase(unittest.TestCase):
 122
 123     def setUp(self):
 124         self.mock_shade_client = mock.Mock()
 125         self.network_name_or_id = 'name_or_id'
 126         self.mock_shade_client.create_subnet = mock.Mock()
 127
 128     def test_create_neutron_subnet(self):
 129         _uuid = uuidutils.generate_uuid()
 130         self.mock_shade_client.create_subnet.return_value = {'id': _uuid}
 131         output = openstack_utils.create_neutron_subnet(
 132             self.mock_shade_client, self.network_name_or_id)
 133         self.assertEqual(_uuid, output)
 134
 135     @mock.patch.object(openstack_utils, 'log')
 136     def test_create_neutron_subnet_exception(self, mock_logger):
 137         self.mock_shade_client.create_subnet.side_effect = (
 138             exc.OpenStackCloudException('error message'))
 139
 140         output = openstack_utils.create_neutron_subnet(
 141             self.mock_shade_client, self.network_name_or_id)
 142         mock_logger.error.assert_called_once()
 143         self.assertIsNone(output)
 144
 145
 146 class DeleteNeutronRouterTestCase(unittest.TestCase):
 147
 148     def setUp(self):
 149         self.mock_shade_client = mock.Mock()
 150         self.mock_shade_client.delete_router = mock.Mock()
 151
 152     def test_delete_neutron_router(self):
 153         self.mock_shade_client.delete_router.return_value = True
 154         output = openstack_utils.delete_neutron_router(self.mock_shade_client,
 155                                                        'router_id')
 156         self.assertTrue(output)
 157
 158     def test_delete_neutron_router_fail(self):
 159         self.mock_shade_client.delete_router.return_value = False
 160         output = openstack_utils.delete_neutron_router(self.mock_shade_client,
 161                                                        'router_id')
 162         self.assertFalse(output)
 163
 164     @mock.patch.object(openstack_utils, 'log')
 165     def test_delete_neutron_router_exception(self, mock_logger):
 166         self.mock_shade_client.delete_router.side_effect = (
 167             exc.OpenStackCloudException('error message'))
 168         output = openstack_utils.delete_neutron_router(self.mock_shade_client,
 169                                                        'router_id')
 170         mock_logger.error.assert_called_once()
 171         self.assertFalse(output)
 172
 173
 174 class CreateNeutronRouterTestCase(unittest.TestCase):
 175
 176     def setUp(self):
 177         self.mock_shade_client = mock.Mock()
 178         self.mock_shade_client.create_subnet = mock.Mock()
 179
 180     def test_create_neutron_router(self):
 181         _uuid = uuidutils.generate_uuid()
 182         self.mock_shade_client.create_router.return_value = {'id': _uuid}
 183         output = openstack_utils.create_neutron_router(
 184             self.mock_shade_client)
 185         self.assertEqual(_uuid, output)
 186
 187     @mock.patch.object(openstack_utils, 'log')
 188     def test_create_neutron_subnet_exception(self, mock_logger):
 189         self.mock_shade_client.create_router.side_effect = (
 190             exc.OpenStackCloudException('error message'))
 191
 192         output = openstack_utils.create_neutron_router(
 193             self.mock_shade_client)
 194         mock_logger.error.assert_called_once()
 195         self.assertIsNone(output)
 196
 197
 198 class RemoveRouterInterfaceTestCase(unittest.TestCase):
 199
 200     def setUp(self):
 201         self.mock_shade_client = mock.Mock()
 202         self.router = 'router'
 203         self.mock_shade_client.remove_router_interface = mock.Mock()
 204
 205     def test_remove_router_interface(self):
 206         self.mock_shade_client.remove_router_interface.return_value = True
 207         output = openstack_utils.remove_router_interface(
 208             self.mock_shade_client, self.router)
 209         self.assertTrue(output)
 210
 211     @mock.patch.object(openstack_utils, 'log')
 212     def test_remove_router_interface_exception(self, mock_logger):
 213         self.mock_shade_client.remove_router_interface.side_effect = (
 214             exc.OpenStackCloudException('error message'))
 215         output = openstack_utils.remove_router_interface(
 216             self.mock_shade_client, self.router)
 217         mock_logger.error.assert_called_once()
 218         self.assertFalse(output)
 219
 220
 221 class CreateFloatingIpTestCase(unittest.TestCase):
 222
 223     def setUp(self):
 224         self.mock_shade_client = mock.Mock()
 225         self.network_name_or_id = 'name'
 226         self.mock_shade_client.create_floating_ip = mock.Mock()
 227
 228     def test_create_floating_ip(self):
 229         self.mock_shade_client.create_floating_ip.return_value = \
 230             {'floating_ip_address': 'value1', 'id': 'value2'}
 231         output = openstack_utils.create_floating_ip(self.mock_shade_client,
 232                                                     self.network_name_or_id)
 233         self.assertEqual({'fip_addr': 'value1', 'fip_id': 'value2'}, output)
 234
 235     @mock.patch.object(openstack_utils, 'log')
 236     def test_create_floating_ip_exception(self, mock_logger):
 237         self.mock_shade_client.create_floating_ip.side_effect = (
 238             exc.OpenStackCloudException('error message'))
 239         output = openstack_utils.create_floating_ip(
 240             self.mock_shade_client, self.network_name_or_id)
 241         mock_logger.error.assert_called_once()
 242         self.assertIsNone(output)
 243
 244
 245 class DeleteFloatingIpTestCase(unittest.TestCase):
 246
 247     def setUp(self):
 248         self.mock_shade_client = mock.Mock()
 249         self.floating_ip_id = 'floating_ip_id'
 250         self.mock_shade_client.delete_floating_ip = mock.Mock()
 251
 252     def test_delete_floating_ip(self):
 253         self.mock_shade_client.delete_floating_ip.return_value = True
 254         output = openstack_utils.delete_floating_ip(self.mock_shade_client,
 255                                                     'floating_ip_id')
 256         self.assertTrue(output)
 257
 258     def test_delete_floating_ip_fail(self):
 259         self.mock_shade_client.delete_floating_ip.return_value = False
 260         output = openstack_utils.delete_floating_ip(self.mock_shade_client,
 261                                                     'floating_ip_id')
 262         self.assertFalse(output)
 263
 264     @mock.patch.object(openstack_utils, 'log')
 265     def test_delete_floating_ip_exception(self, mock_logger):
 266         self.mock_shade_client.delete_floating_ip.side_effect = (
 267             exc.OpenStackCloudException('error message'))
 268         output = openstack_utils.delete_floating_ip(self.mock_shade_client,
 269                                                     'floating_ip_id')
 270         mock_logger.error.assert_called_once()
 271         self.assertFalse(output)
 272
 273
 274 class CreateSecurityGroupRuleTestCase(unittest.TestCase):
 275
 276     def setUp(self):
 277         self.mock_shade_client = mock.Mock()
 278         self.secgroup_name_or_id = 'sg_name_id'
 279         self.mock_shade_client.create_security_group_rule = mock.Mock()
 280
 281     def test_create_security_group_rule(self):
 282         self.mock_shade_client.create_security_group_rule.return_value = (
 283             {'security_group_rule'})
 284         output = openstack_utils.create_security_group_rule(
 285             self.mock_shade_client, self.secgroup_name_or_id)
 286         self.assertTrue(output)
 287
 288     @mock.patch.object(openstack_utils, 'log')
 289     def test_create_security_group_rule_exception(self, mock_logger):
 290         self.mock_shade_client.create_security_group_rule.side_effect = (
 291             exc.OpenStackCloudException('error message'))
 292
 293         output = openstack_utils.create_security_group_rule(
 294             self.mock_shade_client, self.secgroup_name_or_id)
 295         mock_logger.error.assert_called_once()
 296         self.assertFalse(output)
 297
 298
 299 class ListImageTestCase(unittest.TestCase):
 300
 301     def test_list_images(self):
 302         mock_shade_client = mock.MagicMock()
 303         mock_shade_client.list_images.return_value = []
 304         openstack_utils.list_images(mock_shade_client)
 305
 306     @mock.patch.object(openstack_utils, 'log')
 307     def test_list_images_exception(self, mock_logger):
 308         mock_shade_client = mock.MagicMock()
 309         mock_shade_client.list_images = mock.MagicMock()
 310         mock_shade_client.list_images.side_effect = (
 311             exc.OpenStackCloudException('error message'))
 312         images = openstack_utils.list_images(mock_shade_client)
 313         mock_logger.error.assert_called_once()
 314         self.assertFalse(images)
 315
 316
 317 class SecurityGroupTestCase(unittest.TestCase):
 318
 319     def setUp(self):
 320         self.mock_shade_client = mock.Mock()
 321         self.sg_name = 'sg_name'
 322         self.sg_description = 'sg_description'
 323         self._uuid = uuidutils.generate_uuid()
 324
 325     def test_create_security_group_full_existing_security_group(self):
 326         self.mock_shade_client.get_security_group.return_value = (
 327             {'name': 'name', 'id': self._uuid})
 328         output = openstack_utils.create_security_group_full(
 329             self.mock_shade_client, self.sg_name, self.sg_description)
 330         self.mock_shade_client.get_security_group.assert_called_once()
 331         self.assertEqual(self._uuid, output)
 332
 333     @mock.patch.object(openstack_utils, 'log')
 334     def test_create_security_group_full_non_existing_security_group(
 335             self, mock_logger):
 336         self.mock_shade_client.get_security_group.return_value = None
 337         self.mock_shade_client.create_security_group.side_effect = (
 338             exc.OpenStackCloudException('error message'))
 339         output = openstack_utils.create_security_group_full(
 340             self.mock_shade_client, self.sg_name, self.sg_description)
 341         mock_logger.error.assert_called_once()
 342         self.assertIsNone(output)
 343
 344     @mock.patch.object(openstack_utils, 'create_security_group_rule')
 345     @mock.patch.object(openstack_utils, 'log')
 346     def test_create_security_group_full_create_rule_fail(
 347             self, mock_logger, mock_create_security_group_rule):
 348         self.mock_shade_client.get_security_group.return_value = None
 349         self.mock_shade_client.create_security_group.return_value = (
 350             {'name': 'name', 'id': self._uuid})
 351         mock_create_security_group_rule.return_value = False
 352         output = openstack_utils.create_security_group_full(
 353             self.mock_shade_client, self.sg_name, self.sg_description)
 354         mock_create_security_group_rule.assert_called()
 355         self.mock_shade_client.delete_security_group(self.sg_name)
 356         mock_logger.error.assert_called_once()
 357         self.assertIsNone(output)
 358
 359     @mock.patch.object(openstack_utils, 'create_security_group_rule')
 360     def test_create_security_group_full(
 361             self, mock_create_security_group_rule):
 362         self.mock_shade_client.get_security_group.return_value = None
 363         self.mock_shade_client.create_security_group.return_value = (
 364             {'name': 'name', 'id': self._uuid})
 365         mock_create_security_group_rule.return_value = True
 366         output = openstack_utils.create_security_group_full(
 367             self.mock_shade_client, self.sg_name, self.sg_description)
 368         mock_create_security_group_rule.assert_called()
 369         self.mock_shade_client.delete_security_group(self.sg_name)
 370         self.assertEqual(self._uuid, output)
 371
 372 # *********************************************
 373 #   NOVA
 374 # *********************************************
 375
 376
 377 class CreateInstanceTestCase(unittest.TestCase):
 378
 379     def test_create_instance_and_wait_for_active(self):
 380         self.mock_shade_client = mock.Mock()
 381         name = 'server_name'
 382         image = 'image_name'
 383         flavor = 'flavor_name'
 384         self.mock_shade_client.create_server.return_value = (
 385             {'name': name, 'image': image, 'flavor': flavor})
 386         output = openstack_utils.create_instance_and_wait_for_active(
 387             self.mock_shade_client, name, image, flavor)
 388         self.assertEqual(
 389             {'name': name, 'image': image, 'flavor': flavor}, output)
 390
 391     @mock.patch.object(openstack_utils, 'log')
 392     def test_create_instance_and_wait_for_active_fail(self, mock_logger):
 393         self.mock_shade_client = mock.Mock()
 394         self.mock_shade_client.create_server.side_effect = (
 395             exc.OpenStackCloudException('error message'))
 396         output = openstack_utils.create_instance_and_wait_for_active(
 397             self.mock_shade_client, 'server_name', 'image_name', 'flavor_name')
 398         mock_logger.error.assert_called_once()
 399         self.assertIsNone(output)
 400
 401
 402 class DeleteInstanceTestCase(unittest.TestCase):
 403
 404     def setUp(self):
 405         self.mock_shade_client = mock.Mock()
 406
 407     def test_delete_instance(self):
 408         self.mock_shade_client.delete_server.return_value = True
 409         output = openstack_utils.delete_instance(self.mock_shade_client,
 410                                                  'instance_name_id')
 411         self.assertTrue(output)
 412
 413     def test_delete_instance_fail(self):
 414         self.mock_shade_client.delete_server.return_value = False
 415         output = openstack_utils.delete_instance(self.mock_shade_client,
 416                                                  'instance_name_id')
 417         self.assertFalse(output)
 418
 419     @mock.patch.object(openstack_utils, 'log')
 420     def test_delete_instance_exception(self, mock_logger):
 421         self.mock_shade_client.delete_server.side_effect = (
 422             exc.OpenStackCloudException('error message'))
 423         output = openstack_utils.delete_instance(self.mock_shade_client,
 424                                                  'instance_name_id')
 425         mock_logger.error.assert_called_once()
 426         self.assertFalse(output)
 427
 428
 429 class CreateKeypairTestCase(unittest.TestCase):
 430
 431     def setUp(self):
 432         self.mock_shade_client = mock.Mock()
 433         self.name = 'key_name'
 434
 435     def test_create_keypair(self):
 436         self.mock_shade_client.create_keypair.return_value = (
 437             {'name': 'key-name', 'type': 'ssh'})
 438         output = openstack_utils.create_keypair(
 439             self.mock_shade_client, self.name)
 440         self.assertEqual(
 441             {'name': 'key-name', 'type': 'ssh'},
 442             output)
 443
 444     @mock.patch.object(openstack_utils, 'log')
 445     def test_create_keypair_fail(self, mock_logger):
 446         self.mock_shade_client.create_keypair.side_effect = (
 447             exc.OpenStackCloudException('error message'))
 448         output = openstack_utils.create_keypair(
 449             self.mock_shade_client, self.name)
 450         mock_logger.error.assert_called_once()
 451         self.assertIsNone(output)
 452
 453
 454 class DeleteKeypairTestCase(unittest.TestCase):
 455
 456     def setUp(self):
 457         self.mock_shade_client = mock.Mock()
 458
 459     def test_delete_keypair(self):
 460         self.mock_shade_client.delete_keypair.return_value = True
 461         output = openstack_utils.delete_keypair(self.mock_shade_client,
 462                                                 'key_name')
 463         self.assertTrue(output)
 464
 465     def test_delete_keypair_fail(self):
 466         self.mock_shade_client.delete_keypair.return_value = False
 467         output = openstack_utils.delete_keypair(self.mock_shade_client,
 468                                                 'key_name')
 469         self.assertFalse(output)
 470
 471     @mock.patch.object(openstack_utils, 'log')
 472     def test_delete_keypair_exception(self, mock_logger):
 473         self.mock_shade_client.delete_keypair.side_effect = (
 474             exc.OpenStackCloudException('error message'))
 475         output = openstack_utils.delete_keypair(self.mock_shade_client,
 476                                                 'key_name')
 477         mock_logger.error.assert_called_once()
 478         self.assertFalse(output)
 479
 480
 481 class AttachVolumeToServerTestCase(unittest.TestCase):
 482
 483     def test_attach_volume_to_server(self):
 484         self.mock_shade_client = mock.Mock()
 485         self.mock_shade_client.get_server.return_value = {'server_dict'}
 486         self.mock_shade_client.get_volume.return_value = {'volume_dict'}
 487         self.mock_shade_client.attach_volume.return_value = True
 488         output = openstack_utils.attach_volume_to_server(
 489             self.mock_shade_client, 'server_name_or_id', 'volume_name_or_id')
 490         self.assertTrue(output)
 491
 492     @mock.patch.object(openstack_utils, 'log')
 493     def test_attach_volume_to_server_fail(self, mock_logger):
 494         self.mock_shade_client = mock.Mock()
 495         self.mock_shade_client.attach_volume.side_effect = (
 496             exc.OpenStackCloudException('error message'))
 497         output = openstack_utils.attach_volume_to_server(
 498             self.mock_shade_client, 'server_name_or_id', 'volume_name_or_id')
 499         mock_logger.error.assert_called_once()
 500         self.assertFalse(output)
 501
 502
 503 class GetServerTestCase(unittest.TestCase):
 504
 505     def test_get_server(self):
 506         self.mock_shade_client = mock.Mock()
 507         _uuid = uuidutils.generate_uuid()
 508         self.mock_shade_client.get_server.return_value = {
 509             'name': 'server_name', 'id': _uuid}
 510         output = openstack_utils.get_server(self.mock_shade_client,
 511                                             'server_name_or_id')
 512         self.assertEqual({'name': 'server_name', 'id': _uuid}, output)
 513
 514     @mock.patch.object(openstack_utils, 'log')
 515     def test_get_server_exception(self, mock_logger):
 516         self.mock_shade_client = mock.Mock()
 517         self.mock_shade_client.get_server.side_effect = (
 518             exc.OpenStackCloudException('error message'))
 519         output = openstack_utils.get_server(self.mock_shade_client,
 520                                             'server_name_or_id')
 521         mock_logger.error.assert_called_once()
 522         self.assertIsNone(output)
 523
 524
 525 class GetFlavorTestCase(unittest.TestCase):
 526
 527     def test_get_flavor(self):
 528         self.mock_shade_client = mock.Mock()
 529         _uuid = uuidutils.generate_uuid()
 530         self.mock_shade_client.get_flavor.return_value = {
 531             'name': 'flavor_name', 'id': _uuid}
 532         output = openstack_utils.get_flavor(self.mock_shade_client,
 533                                             'flavor_name_or_id')
 534         self.assertEqual({'name': 'flavor_name', 'id': _uuid}, output)
 535
 536     @mock.patch.object(openstack_utils, 'log')
 537     def test_get_flavor_exception(self, mock_logger):
 538         self.mock_shade_client = mock.Mock()
 539         self.mock_shade_client.get_flavor.side_effect = (
 540             exc.OpenStackCloudException('error message'))
 541         output = openstack_utils.get_flavor(self.mock_shade_client,
 542                                             'flavor_name_or_id')
 543         mock_logger.error.assert_called_once()
 544         self.assertIsNone(output)
 545
 546 # *********************************************
 547 #   CINDER
 548 # *********************************************
 549
 550
 551 class GetVolumeIDTestCase(unittest.TestCase):
 552
 553     def test_get_volume_id(self):
 554         self.mock_shade_client = mock.Mock()
 555         _uuid = uuidutils.generate_uuid()
 556         self.mock_shade_client.get_volume_id.return_value = _uuid
 557         output = openstack_utils.get_volume_id(self.mock_shade_client,
 558                                                'volume_name')
 559         self.assertEqual(_uuid, output)
 560
 561     def test_get_volume_id_None(self):
 562         self.mock_shade_client = mock.Mock()
 563         self.mock_shade_client.get_volume_id.return_value = None
 564         output = openstack_utils.get_volume_id(self.mock_shade_client,
 565                                                'volume_name')
 566         self.assertIsNone(output)
 567
 568
 569 class GetVolumeTestCase(unittest.TestCase):
 570
 571     def setUp(self):
 572         self.mock_shade_client = mock.Mock()
 573         self.mock_shade_client.get_volume = mock.Mock()
 574
 575     def test_get_volume(self):
 576         self.mock_shade_client.get_volume.return_value = {'volume'}
 577         output = openstack_utils.get_volume(self.mock_shade_client,
 578                                             'volume_name_or_id')
 579         self.assertEqual({'volume'}, output)
 580
 581     def test_get_volume_None(self):
 582         self.mock_shade_client.get_volume.return_value = None
 583         output = openstack_utils.get_volume(self.mock_shade_client,
 584                                             'volume_name_or_id')
 585         self.assertIsNone(output)
 586
 587
 588 class CreateVolumeTestCase(unittest.TestCase):
 589
 590     def setUp(self):
 591         self.mock_shade_client = mock.Mock()
 592         self.size = 1
 593
 594     def test_create_volume(self):
 595         self.mock_shade_client.create_volume.return_value = (
 596             {'name': 'volume-name', 'size': self.size})
 597         output = openstack_utils.create_volume(
 598             self.mock_shade_client, self.size)
 599         self.assertEqual(
 600             {'name': 'volume-name', 'size': self.size},
 601             output)
 602
 603     @mock.patch.object(openstack_utils, 'log')
 604     def test_create_volume_fail(self, mock_logger):
 605         self.mock_shade_client.create_volume.side_effect = (
 606             exc.OpenStackCloudException('error message'))
 607         output = openstack_utils.create_volume(self.mock_shade_client,
 608                                                self.size)
 609         mock_logger.error.assert_called_once()
 610         self.assertIsNone(output)
 611
 612
 613 class DeleteVolumeTestCase(unittest.TestCase):
 614
 615     def setUp(self):
 616         self.mock_shade_client = mock.Mock()
 617
 618     def test_delete_volume(self):
 619         self.mock_shade_client.delete_volume.return_value = True
 620         output = openstack_utils.delete_volume(self.mock_shade_client,
 621                                                'volume_name_or_id')
 622         self.assertTrue(output)
 623
 624     def test_delete_volume_fail(self):
 625         self.mock_shade_client.delete_volume.return_value = False
 626         output = openstack_utils.delete_volume(self.mock_shade_client,
 627                                                'volume_name_or_id')
 628         self.assertFalse(output)
 629
 630     @mock.patch.object(openstack_utils, 'log')
 631     def test_delete_volume_exception(self, mock_logger):
 632         self.mock_shade_client.delete_volume.side_effect = (
 633             exc.OpenStackCloudException('error message'))
 634         output = openstack_utils.delete_volume(self.mock_shade_client,
 635                                                'volume_name_or_id')
 636         mock_logger.error.assert_called_once()
 637         self.assertFalse(output)
 638
 639
 640 class DetachVolumeTestCase(unittest.TestCase):
 641
 642     @mock.patch.object(openstack_utils, 'get_server')
 643     def test_detach_volume(self, mock_get_server):
 644         self.mock_shade_client = mock.Mock()
 645         mock_get_server.return_value = {'server_dict'}
 646         self.mock_shade_client.get_volume.return_value = {'volume_dict'}
 647         output = openstack_utils.detach_volume(self.mock_shade_client,
 648                                                'server_name_or_id',
 649                                                'volume_name_or_id')
 650         self.assertTrue(output)
 651
 652     @mock.patch.object(openstack_utils, 'get_server')
 653     @mock.patch.object(openstack_utils, 'log')
 654     def test_detach_volume_exception(self, mock_logger, mock_get_server):
 655         self.mock_shade_client = mock.Mock()
 656         mock_get_server.return_value = {'server_dict'}
 657         self.mock_shade_client.get_volume.return_value = {'volume_dict'}
 658         self.mock_shade_client.detach_volume.side_effect = (
 659             exc.OpenStackCloudException('error message'))
 660         output = openstack_utils.detach_volume(self.mock_shade_client,
 661                                                'server_name_or_id',
 662                                                'volume_name_or_id')
 663         mock_logger.error.assert_called_once()
 664         self.assertFalse(output)
 665
 666
 667 # *********************************************
 668 #   GLANCE
 669 # *********************************************
 670
 671 class CreateImageTestCase(unittest.TestCase):
 672
 673     def setUp(self):
 674         self.mock_shade_client = mock.Mock()
 675         self._uuid = uuidutils.generate_uuid()
 676         self.name = 'image_name'
 677
 678     @mock.patch.object(openstack_utils, 'log')
 679     def test_create_image_already_exit(self, mock_logger):
 680         self.mock_shade_client.get_image_id.return_value = self._uuid
 681         output = openstack_utils.create_image(self.mock_shade_client, self.name)
 682         mock_logger.info.assert_called_once()
 683         self.assertEqual(self._uuid, output)
 684
 685     def test_create_image(self):
 686         self.mock_shade_client.get_image_id.return_value = None
 687         self.mock_shade_client.create_image.return_value = {'id': self._uuid}
 688         output = openstack_utils.create_image(self.mock_shade_client, self.name)
 689         self.assertEqual(self._uuid, output)
 690
 691     @mock.patch.object(openstack_utils, 'log')
 692     def test_create_image_exception(self, mock_logger):
 693         self.mock_shade_client.get_image_id.return_value = None
 694         self.mock_shade_client.create_image.side_effect = (
 695             exc.OpenStackCloudException('error message'))
 696
 697         output = openstack_utils.create_image(self.mock_shade_client,
 698                                               self.name)
 699         mock_logger.error.assert_called_once()
 700         self.assertIsNone(output)
 701
 702
 703 class DeleteImageTestCase(unittest.TestCase):
 704
 705     def test_delete_image(self):
 706         self.mock_shade_client = mock.Mock()
 707         self.mock_shade_client.delete_image.return_value = True
 708         output = openstack_utils.delete_image(self.mock_shade_client,
 709                                               'image_name_or_id')
 710         self.assertTrue(output)
 711
 712     def test_delete_image_fail(self):
 713         self.mock_shade_client = mock.Mock()
 714         self.mock_shade_client.delete_image.return_value = False
 715         output = openstack_utils.delete_image(self.mock_shade_client,
 716                                               'image_name_or_id')
 717         self.assertFalse(output)
 718
 719     @mock.patch.object(openstack_utils, 'log')
 720     def test_delete_image_exception(self, mock_logger):
 721         self.mock_shade_client = mock.Mock()
 722         self.mock_shade_client.delete_image.side_effect = (
 723             exc.OpenStackCloudException('error message'))
 724         output = openstack_utils.delete_image(self.mock_shade_client,
 725                                               'image_name_or_id')
 726         mock_logger.error.assert_called_once()
 727         self.assertFalse(output)