functest/tests/unit/utils/test_openstack_utils.py

   1 #!/usr/bin/env python
   2
   3 # All rights reserved. This program and the accompanying materials
   4 # are made available under the terms of the Apache License, Version 2.0
   5 # which accompanies this distribution, and is available at
   6 # http://www.apache.org/licenses/LICENSE-2.0
   7
   8 # pylint: disable=missing-docstring
   9
  10 import copy
  11 import logging
  12 import os
  13 import unittest
  14
  15 import mock
  16
  17 from functest.utils import openstack_utils
  18
  19
  20 class OSUtilsTesting(unittest.TestCase):
  21
  22     def _get_env_cred_dict(self, os_prefix=''):
  23         return {'OS_USERNAME': os_prefix + 'username',
  24                 'OS_PASSWORD': os_prefix + 'password',
  25                 'OS_AUTH_URL': os_prefix + 'auth_url',
  26                 'OS_TENANT_NAME': os_prefix + 'tenant_name',
  27                 'OS_USER_DOMAIN_NAME': os_prefix + 'user_domain_name',
  28                 'OS_PROJECT_DOMAIN_NAME': os_prefix + 'project_domain_name',
  29                 'OS_PROJECT_NAME': os_prefix + 'project_name',
  30                 'OS_ENDPOINT_TYPE': os_prefix + 'endpoint_type',
  31                 'OS_REGION_NAME': os_prefix + 'region_name',
  32                 'OS_CACERT': os_prefix + 'https_cacert',
  33                 'OS_INSECURE': os_prefix + 'https_insecure'}
  34
  35     def _get_os_env_vars(self):
  36         return {'username': 'test_username', 'password': 'test_password',
  37                 'auth_url': 'test_auth_url', 'tenant_name': 'test_tenant_name',
  38                 'user_domain_name': 'test_user_domain_name',
  39                 'project_domain_name': 'test_project_domain_name',
  40                 'project_name': 'test_project_name',
  41                 'endpoint_type': 'test_endpoint_type',
  42                 'region_name': 'test_region_name',
  43                 'https_cacert': 'test_https_cacert',
  44                 'https_insecure': 'test_https_insecure'}
  45
  46     def setUp(self):
  47         self.env_vars = ['OS_AUTH_URL', 'OS_USERNAME', 'OS_PASSWORD']
  48         self.tenant_name = 'test_tenant_name'
  49         self.env_cred_dict = self._get_env_cred_dict()
  50         self.os_environs = self._get_env_cred_dict(os_prefix='test_')
  51         self.os_env_vars = self._get_os_env_vars()
  52
  53         mock_obj = mock.Mock()
  54         attrs = {'name': 'test_flavor',
  55                  'id': 'flavor_id',
  56                  'ram': 2}
  57         mock_obj.configure_mock(**attrs)
  58         self.flavor = mock_obj
  59
  60         mock_obj = mock.Mock()
  61         attrs = {'name': 'test_aggregate',
  62                  'id': 'aggregate_id',
  63                  'hosts': ['host_name']}
  64         mock_obj.configure_mock(**attrs)
  65         self.aggregate = mock_obj
  66
  67         mock_obj = mock.Mock()
  68         attrs = {'id': 'instance_id',
  69                  'name': 'test_instance',
  70                  'status': 'ok'}
  71         mock_obj.configure_mock(**attrs)
  72         self.instance = mock_obj
  73
  74         mock_obj = mock.Mock()
  75         attrs = {'id': 'azone_id',
  76                  'zoneName': 'test_azone',
  77                  'status': 'ok'}
  78         mock_obj.configure_mock(**attrs)
  79         self.availability_zone = mock_obj
  80
  81         mock_obj = mock.Mock()
  82         attrs = {'floating_network_id': 'floating_id',
  83                  'floating_ip_address': 'test_floating_ip'}
  84         mock_obj.configure_mock(**attrs)
  85         self.floating_ip = mock_obj
  86
  87         mock_obj = mock.Mock()
  88         attrs = {'id': 'hypervisor_id',
  89                  'hypervisor_hostname': 'test_hostname',
  90                  'state': 'up'}
  91         mock_obj.configure_mock(**attrs)
  92         self.hypervisor = mock_obj
  93
  94         mock_obj = mock.Mock()
  95         attrs = {'id': 'image_id',
  96                  'name': 'test_image'}
  97         mock_obj.configure_mock(**attrs)
  98         self.image = mock_obj
  99
 100         mock_obj = mock.Mock()
 101         self.mock_return = mock_obj
 102
 103         self.nova_client = mock.Mock()
 104         attrs = {'servers.list.return_value': [self.instance],
 105                  'servers.get.return_value': self.instance,
 106                  'servers.find.return_value': self.instance,
 107                  'servers.create.return_value': self.instance,
 108                  'flavors.list.return_value': [self.flavor],
 109                  'flavors.find.return_value': self.flavor,
 110                  'servers.add_floating_ip.return_value': mock.Mock(),
 111                  'servers.force_delete.return_value': mock.Mock(),
 112                  'aggregates.list.return_value': [self.aggregate],
 113                  'aggregates.add_host.return_value': mock.Mock(),
 114                  'aggregates.remove_host.return_value': mock.Mock(),
 115                  'aggregates.get.return_value': self.aggregate,
 116                  'aggregates.delete.return_value': mock.Mock(),
 117                  'availability_zones.list.return_value':
 118                  [self.availability_zone],
 119                  'hypervisors.list.return_value': [self.hypervisor],
 120                  'create.return_value': mock.Mock(),
 121                  'add_security_group.return_value': mock.Mock(),
 122                  'images.list.return_value': [self.image],
 123                  'images.delete.return_value': mock.Mock(),
 124                  }
 125         self.nova_client.configure_mock(**attrs)
 126
 127         self.glance_client = mock.Mock()
 128         attrs = {'images.list.return_value': [self.image],
 129                  'images.create.return_value': self.image,
 130                  'images.upload.return_value': mock.Mock()}
 131         self.glance_client.configure_mock(**attrs)
 132
 133         mock_obj = mock.Mock()
 134         attrs = {'id': 'volume_id',
 135                  'name': 'test_volume'}
 136         mock_obj.configure_mock(**attrs)
 137         self.volume = mock_obj
 138
 139         self.cinder_client = mock.Mock()
 140         attrs = {'volumes.list.return_value': [self.volume],
 141                  'quotas.update.return_value': mock.Mock(),
 142                  'volumes.detach.return_value': mock.Mock(),
 143                  'volumes.force_delete.return_value': mock.Mock(),
 144                  'volumes.delete.return_value': mock.Mock()
 145                  }
 146         self.cinder_client.configure_mock(**attrs)
 147
 148         self.resource = mock.Mock()
 149         attrs = {'id': 'resource_test_id',
 150                  'name': 'resource_test_name'
 151                  }
 152
 153         self.heat_client = mock.Mock()
 154         attrs = {'resources.get.return_value': self.resource}
 155         self.heat_client.configure_mock(**attrs)
 156
 157         mock_obj = mock.Mock()
 158         attrs = {'id': 'tenant_id',
 159                  'name': 'test_tenant'}
 160         mock_obj.configure_mock(**attrs)
 161         self.tenant = mock_obj
 162
 163         mock_obj = mock.Mock()
 164         attrs = {'id': 'user_id',
 165                  'name': 'test_user'}
 166         mock_obj.configure_mock(**attrs)
 167         self.user = mock_obj
 168
 169         mock_obj = mock.Mock()
 170         attrs = {'id': 'role_id',
 171                  'name': 'test_role'}
 172         mock_obj.configure_mock(**attrs)
 173         self.role = mock_obj
 174
 175         mock_obj = mock.Mock()
 176         attrs = {'id': 'domain_id',
 177                  'name': 'test_domain'}
 178         mock_obj.configure_mock(**attrs)
 179         self.domain = mock_obj
 180
 181         self.keystone_client = mock.Mock()
 182         attrs = {'projects.list.return_value': [self.tenant],
 183                  'tenants.list.return_value': [self.tenant],
 184                  'users.list.return_value': [self.user],
 185                  'roles.list.return_value': [self.role],
 186                  'domains.list.return_value': [self.domain],
 187                  'projects.create.return_value': self.tenant,
 188                  'tenants.create.return_value': self.tenant,
 189                  'users.create.return_value': self.user,
 190                  'roles.grant.return_value': mock.Mock(),
 191                  'roles.add_user_role.return_value': mock.Mock(),
 192                  'projects.delete.return_value': mock.Mock(),
 193                  'tenants.delete.return_value': mock.Mock(),
 194                  'users.delete.return_value': mock.Mock(),
 195                  }
 196         self.keystone_client.configure_mock(**attrs)
 197
 198         self.router = {'id': 'router_id',
 199                        'name': 'test_router'}
 200
 201         self.subnet = {'id': 'subnet_id',
 202                        'name': 'test_subnet'}
 203
 204         self.networks = [{'id': 'network_id',
 205                           'name': 'test_network',
 206                           'router:external': False,
 207                           'shared': True,
 208                           'subnets': [self.subnet]},
 209                          {'id': 'network_id1',
 210                           'name': 'test_network1',
 211                           'router:external': True,
 212                           'shared': True,
 213                           'subnets': [self.subnet]}]
 214
 215         self.port = {'id': 'port_id',
 216                      'name': 'test_port'}
 217
 218         self.sec_group = {'id': 'sec_group_id',
 219                           'name': 'test_sec_group'}
 220
 221         self.sec_group_rule = {'id': 'sec_group_rule_id',
 222                                'direction': 'direction',
 223                                'protocol': 'protocol',
 224                                'port_range_max': 'port_max',
 225                                'security_group_id': self.sec_group['id'],
 226                                'port_range_min': 'port_min'}
 227         self.neutron_floatingip = {'id': 'fip_id',
 228                                    'floating_ip_address': 'test_ip'}
 229         self.neutron_client = mock.Mock()
 230         attrs = {'list_networks.return_value': {'networks': self.networks},
 231                  'list_routers.return_value': {'routers': [self.router]},
 232                  'list_ports.return_value': {'ports': [self.port]},
 233                  'list_subnets.return_value': {'subnets': [self.subnet]},
 234                  'create_network.return_value': {'network': self.networks[0]},
 235                  'create_subnet.return_value': {'subnets': [self.subnet]},
 236                  'create_router.return_value': {'router': self.router},
 237                  'create_port.return_value': {'port': self.port},
 238                  'create_floatingip.return_value': {'floatingip':
 239                                                     self.neutron_floatingip},
 240                  'update_network.return_value': mock.Mock(),
 241                  'update_port.return_value': {'port': self.port},
 242                  'add_interface_router.return_value': mock.Mock(),
 243                  'add_gateway_router.return_value': mock.Mock(),
 244                  'delete_network.return_value': mock.Mock(),
 245                  'delete_subnet.return_value': mock.Mock(),
 246                  'delete_router.return_value': mock.Mock(),
 247                  'delete_port.return_value': mock.Mock(),
 248                  'remove_interface_router.return_value': mock.Mock(),
 249                  'remove_gateway_router.return_value': mock.Mock(),
 250                  'list_security_groups.return_value': {'security_groups':
 251                                                        [self.sec_group]},
 252                  'list_security_group_rules.'
 253                  'return_value': {'security_group_rules':
 254                                   [self.sec_group_rule]},
 255                  'create_security_group_rule.return_value': mock.Mock(),
 256                  'create_security_group.return_value': {'security_group':
 257                                                         self.sec_group},
 258                  'update_quota.return_value': mock.Mock(),
 259                  'delete_security_group.return_value': mock.Mock(),
 260                  'list_floatingips.return_value': {'floatingips':
 261                                                    [self.floating_ip]},
 262                  'delete_floatingip.return_value': mock.Mock(),
 263                  }
 264         self.neutron_client.configure_mock(**attrs)
 265
 266         self.empty_client = mock.Mock()
 267         attrs = {'list_networks.return_value': {'networks': []},
 268                  'list_routers.return_value': {'routers': []},
 269                  'list_ports.return_value': {'ports': []},
 270                  'list_subnets.return_value': {'subnets': []}}
 271         self.empty_client.configure_mock(**attrs)
 272
 273     @mock.patch('functest.utils.openstack_utils.os.getenv',
 274                 return_value=None)
 275     def test_is_keystone_v3_missing_identity(self, mock_os_getenv):
 276         self.assertEqual(openstack_utils.is_keystone_v3(), False)
 277
 278     @mock.patch('functest.utils.openstack_utils.os.getenv',
 279                 return_value='3')
 280     def test_is_keystone_v3_default(self, mock_os_getenv):
 281         self.assertEqual(openstack_utils.is_keystone_v3(), True)
 282
 283     @mock.patch('functest.utils.openstack_utils.is_keystone_v3',
 284                 return_value=False)
 285     def test_get_rc_env_vars_missing_identity(self, mock_get_rc_env):
 286         exp_resp = self.env_vars
 287         exp_resp.extend(['OS_TENANT_NAME'])
 288         self.assertEqual(openstack_utils.get_rc_env_vars(), exp_resp)
 289
 290     @mock.patch('functest.utils.openstack_utils.is_keystone_v3',
 291                 return_value=True)
 292     def test_get_rc_env_vars_default(self, mock_get_rc_env):
 293         exp_resp = self.env_vars
 294         exp_resp.extend(['OS_PROJECT_NAME',
 295                          'OS_USER_DOMAIN_NAME',
 296                          'OS_PROJECT_DOMAIN_NAME'])
 297         self.assertEqual(openstack_utils.get_rc_env_vars(), exp_resp)
 298
 299     @mock.patch('functest.utils.openstack_utils.get_rc_env_vars')
 300     def test_check_credentials_missing_env(self, mock_get_rc_env):
 301         exp_resp = self.env_vars
 302         exp_resp.extend(['OS_TENANT_NAME'])
 303         mock_get_rc_env.return_value = exp_resp
 304         with mock.patch.dict('functest.utils.openstack_utils.os.environ', {},
 305                              clear=True):
 306             self.assertEqual(openstack_utils.check_credentials(), False)
 307
 308     @mock.patch('functest.utils.openstack_utils.get_rc_env_vars')
 309     def test_check_credentials_default(self, mock_get_rc_env):
 310         exp_resp = ['OS_TENANT_NAME']
 311         mock_get_rc_env.return_value = exp_resp
 312         with mock.patch.dict('functest.utils.openstack_utils.os.environ',
 313                              {'OS_TENANT_NAME': self.tenant_name},
 314                              clear=True):
 315             self.assertEqual(openstack_utils.check_credentials(), True)
 316
 317     def test_get_env_cred_dict(self):
 318         self.assertDictEqual(openstack_utils.get_env_cred_dict(),
 319                              self.env_cred_dict)
 320
 321     @mock.patch('functest.utils.openstack_utils.get_rc_env_vars')
 322     def test_get_credentials_default(self, mock_get_rc_env):
 323         mock_get_rc_env.return_value = self.env_cred_dict.keys()
 324         with mock.patch.dict('functest.utils.openstack_utils.os.environ',
 325                              self.os_environs,
 326                              clear=True):
 327             self.assertDictEqual(openstack_utils.get_credentials(),
 328                                  self.os_env_vars)
 329
 330     def _get_credentials_missing_env(self, var):
 331         dic = copy.deepcopy(self.os_environs)
 332         dic.pop(var)
 333         with mock.patch('functest.utils.openstack_utils.get_rc_env_vars',
 334                         return_value=self.env_cred_dict.keys()), \
 335                 mock.patch.dict('functest.utils.openstack_utils.os.environ',
 336                                 dic,
 337                                 clear=True):
 338             self.assertRaises(openstack_utils.MissingEnvVar,
 339                               lambda: openstack_utils.get_credentials())
 340
 341     def test_get_credentials_missing_username(self):
 342         self._get_credentials_missing_env('OS_USERNAME')
 343
 344     def test_get_credentials_missing_password(self):
 345         self._get_credentials_missing_env('OS_PASSWORD')
 346
 347     def test_get_credentials_missing_auth_url(self):
 348         self._get_credentials_missing_env('OS_AUTH_URL')
 349
 350     def test_get_credentials_missing_tenantname(self):
 351         self._get_credentials_missing_env('OS_TENANT_NAME')
 352
 353     def test_get_credentials_missing_domainname(self):
 354         self._get_credentials_missing_env('OS_USER_DOMAIN_NAME')
 355
 356     def test_get_credentials_missing_projectname(self):
 357         self._get_credentials_missing_env('OS_PROJECT_NAME')
 358
 359     def test_get_credentials_missing_endpoint_type(self):
 360         self._get_credentials_missing_env('OS_ENDPOINT_TYPE')
 361
 362     @mock.patch('functest.utils.openstack_utils.os.getenv',
 363                 return_value=None)
 364     def test_get_keystone_client_version_missing_env(self, mock_os_getenv):
 365         self.assertEqual(openstack_utils.get_keystone_client_version(),
 366                          openstack_utils.DEFAULT_API_VERSION)
 367
 368     @mock.patch('functest.utils.openstack_utils.logger.info')
 369     @mock.patch('functest.utils.openstack_utils.os.getenv',
 370                 return_value='3')
 371     def test_get_keystone_client_version_default(self, mock_os_getenv,
 372                                                  mock_logger_info):
 373         self.assertEqual(openstack_utils.get_keystone_client_version(),
 374                          '3')
 375         mock_logger_info.assert_called_once_with("OS_IDENTITY_API_VERSION is "
 376                                                  "set in env as '%s'", '3')
 377
 378     @mock.patch('functest.utils.openstack_utils.get_session')
 379     @mock.patch('functest.utils.openstack_utils.keystoneclient.Client')
 380     @mock.patch('functest.utils.openstack_utils.get_keystone_client_version',
 381                 return_value='3')
 382     @mock.patch('functest.utils.openstack_utils.os.getenv',
 383                 return_value='public')
 384     def test_get_keystone_client_with_interface(self, mock_os_getenv,
 385                                                 mock_keystoneclient_version,
 386                                                 mock_key_client,
 387                                                 mock_get_session):
 388         mock_keystone_obj = mock.Mock()
 389         mock_session_obj = mock.Mock()
 390         mock_key_client.return_value = mock_keystone_obj
 391         mock_get_session.return_value = mock_session_obj
 392         self.assertEqual(openstack_utils.get_keystone_client(),
 393                          mock_keystone_obj)
 394         mock_key_client.assert_called_once_with('3',
 395                                                 session=mock_session_obj,
 396                                                 interface='public')
 397
 398     @mock.patch('functest.utils.openstack_utils.get_session')
 399     @mock.patch('functest.utils.openstack_utils.keystoneclient.Client')
 400     @mock.patch('functest.utils.openstack_utils.get_keystone_client_version',
 401                 return_value='3')
 402     @mock.patch('functest.utils.openstack_utils.os.getenv',
 403                 return_value='admin')
 404     def test_get_keystone_client_no_interface(self, mock_os_getenv,
 405                                               mock_keystoneclient_version,
 406                                               mock_key_client,
 407                                               mock_get_session):
 408         mock_keystone_obj = mock.Mock()
 409         mock_session_obj = mock.Mock()
 410         mock_key_client.return_value = mock_keystone_obj
 411         mock_get_session.return_value = mock_session_obj
 412         self.assertEqual(openstack_utils.get_keystone_client(),
 413                          mock_keystone_obj)
 414         mock_key_client.assert_called_once_with('3',
 415                                                 session=mock_session_obj,
 416                                                 interface='admin')
 417
 418     @mock.patch('functest.utils.openstack_utils.os.getenv',
 419                 return_value=None)
 420     def test_get_nova_client_version_missing_env(self, mock_os_getenv):
 421         self.assertEqual(openstack_utils.get_nova_client_version(),
 422                          openstack_utils.DEFAULT_API_VERSION)
 423
 424     @mock.patch('functest.utils.openstack_utils.logger.info')
 425     @mock.patch('functest.utils.openstack_utils.os.getenv',
 426                 return_value='3')
 427     def test_get_nova_client_version_default(self, mock_os_getenv,
 428                                              mock_logger_info):
 429         self.assertEqual(openstack_utils.get_nova_client_version(),
 430                          '3')
 431         mock_logger_info.assert_called_once_with("OS_COMPUTE_API_VERSION is "
 432                                                  "set in env as '%s'", '3')
 433
 434     def test_get_nova_client(self):
 435         mock_nova_obj = mock.Mock()
 436         mock_session_obj = mock.Mock()
 437         with mock.patch('functest.utils.openstack_utils'
 438                         '.get_nova_client_version', return_value='3'), \
 439             mock.patch('functest.utils.openstack_utils'
 440                        '.novaclient.Client',
 441                        return_value=mock_nova_obj) \
 442             as mock_nova_client, \
 443             mock.patch('functest.utils.openstack_utils.get_session',
 444                        return_value=mock_session_obj):
 445             self.assertEqual(openstack_utils.get_nova_client(),
 446                              mock_nova_obj)
 447             mock_nova_client.assert_called_once_with('3',
 448                                                      session=mock_session_obj)
 449
 450     @mock.patch('functest.utils.openstack_utils.os.getenv',
 451                 return_value=None)
 452     def test_get_cinder_client_version_missing_env(self, mock_os_getenv):
 453         self.assertEqual(openstack_utils.get_cinder_client_version(),
 454                          openstack_utils.DEFAULT_API_VERSION)
 455
 456     @mock.patch('functest.utils.openstack_utils.logger.info')
 457     @mock.patch('functest.utils.openstack_utils.os.getenv',
 458                 return_value='3')
 459     def test_get_cinder_client_version_default(self, mock_os_getenv,
 460                                                mock_logger_info):
 461         self.assertEqual(openstack_utils.get_cinder_client_version(),
 462                          '3')
 463         mock_logger_info.assert_called_once_with("OS_VOLUME_API_VERSION is "
 464                                                  "set in env as '%s'", '3')
 465
 466     def test_get_cinder_client(self):
 467         mock_cinder_obj = mock.Mock()
 468         mock_session_obj = mock.Mock()
 469         with mock.patch('functest.utils.openstack_utils'
 470                         '.get_cinder_client_version', return_value='3'), \
 471             mock.patch('functest.utils.openstack_utils'
 472                        '.cinderclient.Client',
 473                        return_value=mock_cinder_obj) \
 474             as mock_cind_client, \
 475             mock.patch('functest.utils.openstack_utils.get_session',
 476                        return_value=mock_session_obj):
 477             self.assertEqual(openstack_utils.get_cinder_client(),
 478                              mock_cinder_obj)
 479             mock_cind_client.assert_called_once_with('3',
 480                                                      session=mock_session_obj)
 481
 482     @mock.patch('functest.utils.openstack_utils.os.getenv',
 483                 return_value=None)
 484     def test_get_neutron_client_version_missing_env(self, mock_os_getenv):
 485         self.assertEqual(openstack_utils.get_neutron_client_version(),
 486                          openstack_utils.DEFAULT_API_VERSION)
 487
 488     @mock.patch('functest.utils.openstack_utils.logger.info')
 489     @mock.patch('functest.utils.openstack_utils.os.getenv',
 490                 return_value='3')
 491     def test_get_neutron_client_version_default(self, mock_os_getenv,
 492                                                 mock_logger_info):
 493         self.assertEqual(openstack_utils.get_neutron_client_version(),
 494                          '3')
 495         mock_logger_info.assert_called_once_with("OS_NETWORK_API_VERSION is "
 496                                                  "set in env as '%s'", '3')
 497
 498     def test_get_neutron_client(self):
 499         mock_neutron_obj = mock.Mock()
 500         mock_session_obj = mock.Mock()
 501         with mock.patch('functest.utils.openstack_utils'
 502                         '.get_neutron_client_version', return_value='3'), \
 503             mock.patch('functest.utils.openstack_utils'
 504                        '.neutronclient.Client',
 505                        return_value=mock_neutron_obj) \
 506             as mock_neut_client, \
 507             mock.patch('functest.utils.openstack_utils.get_session',
 508                        return_value=mock_session_obj):
 509             self.assertEqual(openstack_utils.get_neutron_client(),
 510                              mock_neutron_obj)
 511             mock_neut_client.assert_called_once_with('3',
 512                                                      session=mock_session_obj)
 513
 514     @mock.patch('functest.utils.openstack_utils.os.getenv',
 515                 return_value=None)
 516     def test_get_glance_client_version_missing_env(self, mock_os_getenv):
 517         self.assertEqual(openstack_utils.get_glance_client_version(),
 518                          openstack_utils.DEFAULT_API_VERSION)
 519
 520     @mock.patch('functest.utils.openstack_utils.logger.info')
 521     @mock.patch('functest.utils.openstack_utils.os.getenv',
 522                 return_value='3')
 523     def test_get_glance_client_version_default(self, mock_os_getenv,
 524                                                mock_logger_info):
 525         self.assertEqual(openstack_utils.get_glance_client_version(),
 526                          '3')
 527         mock_logger_info.assert_called_once_with("OS_IMAGE_API_VERSION is "
 528                                                  "set in env as '%s'", '3')
 529
 530     def test_get_glance_client(self):
 531         mock_glance_obj = mock.Mock()
 532         mock_session_obj = mock.Mock()
 533         with mock.patch('functest.utils.openstack_utils'
 534                         '.get_glance_client_version', return_value='3'), \
 535             mock.patch('functest.utils.openstack_utils'
 536                        '.glanceclient.Client',
 537                        return_value=mock_glance_obj) \
 538             as mock_glan_client, \
 539             mock.patch('functest.utils.openstack_utils.get_session',
 540                        return_value=mock_session_obj):
 541             self.assertEqual(openstack_utils.get_glance_client(),
 542                              mock_glance_obj)
 543             mock_glan_client.assert_called_once_with('3',
 544                                                      session=mock_session_obj)
 545
 546     @mock.patch('functest.utils.openstack_utils.os.getenv',
 547                 return_value=None)
 548     def test_get_heat_client_version_missing_env(self, mock_os_getenv):
 549         self.assertEqual(openstack_utils.get_heat_client_version(),
 550                          openstack_utils.DEFAULT_HEAT_API_VERSION)
 551
 552     @mock.patch('functest.utils.openstack_utils.logger.info')
 553     @mock.patch('functest.utils.openstack_utils.os.getenv', return_value='1')
 554     def test_get_heat_client_version_default(self, mock_os_getenv,
 555                                              mock_logger_info):
 556         self.assertEqual(openstack_utils.get_heat_client_version(), '1')
 557         mock_logger_info.assert_called_once_with(
 558             "OS_ORCHESTRATION_API_VERSION is set in env as '%s'", '1')
 559
 560     def test_get_heat_client(self):
 561         mock_heat_obj = mock.Mock()
 562         mock_session_obj = mock.Mock()
 563         with mock.patch('functest.utils.openstack_utils'
 564                         '.get_heat_client_version', return_value='1'), \
 565             mock.patch('functest.utils.openstack_utils'
 566                        '.heatclient.Client',
 567                        return_value=mock_heat_obj) \
 568             as mock_heat_client, \
 569             mock.patch('functest.utils.openstack_utils.get_session',
 570                        return_value=mock_session_obj):
 571             self.assertEqual(openstack_utils.get_heat_client(),
 572                              mock_heat_obj)
 573             mock_heat_client.assert_called_once_with('1',
 574                                                      session=mock_session_obj)
 575
 576     def test_get_instances_default(self):
 577         self.assertEqual(openstack_utils.get_instances(self.nova_client),
 578                          [self.instance])
 579
 580     @mock.patch('functest.utils.openstack_utils.logger.error')
 581     def test_get_instances_exception(self, mock_logger_error):
 582             self.assertEqual(openstack_utils.
 583                              get_instances(Exception),
 584                              None)
 585             self.assertTrue(mock_logger_error.called)
 586
 587     def test_get_instance_status_default(self):
 588         self.assertEqual(openstack_utils.get_instance_status(self.nova_client,
 589                                                              self.instance),
 590                          'ok')
 591
 592     @mock.patch('functest.utils.openstack_utils.logger.error')
 593     def test_get_instance_status_exception(self, mock_logger_error):
 594             self.assertEqual(openstack_utils.
 595                              get_instance_status(Exception,
 596                                                  self.instance),
 597                              None)
 598             self.assertTrue(mock_logger_error.called)
 599
 600     def test_get_instance_by_name_default(self):
 601         self.assertEqual(openstack_utils.
 602                          get_instance_by_name(self.nova_client,
 603                                               'test_instance'),
 604                          self.instance)
 605
 606     @mock.patch('functest.utils.openstack_utils.logger.error')
 607     def test_get_instance_by_name_exception(self, mock_logger_error):
 608             self.assertEqual(openstack_utils.
 609                              get_instance_by_name(Exception,
 610                                                   'test_instance'),
 611                              None)
 612             self.assertTrue(mock_logger_error.called)
 613
 614     def test_get_flavor_id_default(self):
 615         self.assertEqual(openstack_utils.
 616                          get_flavor_id(self.nova_client,
 617                                        'test_flavor'),
 618                          self.flavor.id)
 619
 620     def test_get_flavor_id_by_ram_range_default(self):
 621         self.assertEqual(openstack_utils.
 622                          get_flavor_id_by_ram_range(self.nova_client,
 623                                                     1, 3),
 624                          self.flavor.id)
 625
 626     def test_get_aggregates_default(self):
 627         self.assertEqual(openstack_utils.
 628                          get_aggregates(self.nova_client),
 629                          [self.aggregate])
 630
 631     @mock.patch('functest.utils.openstack_utils.logger.error')
 632     def test_get_aggregates_exception(self, mock_logger_error):
 633             self.assertEqual(openstack_utils.
 634                              get_aggregates(Exception),
 635                              None)
 636             self.assertTrue(mock_logger_error.called)
 637
 638     def test_get_aggregate_id_default(self):
 639         with mock.patch('functest.utils.openstack_utils.get_aggregates',
 640                         return_value=[self.aggregate]):
 641             self.assertEqual(openstack_utils.
 642                              get_aggregate_id(self.nova_client,
 643                                               'test_aggregate'),
 644                              'aggregate_id')
 645
 646     @mock.patch('functest.utils.openstack_utils.logger.error')
 647     def test_get_aggregate_id_exception(self, mock_logger_error):
 648             self.assertEqual(openstack_utils.
 649                              get_aggregate_id(Exception,
 650                                               'test_aggregate'),
 651                              None)
 652             self.assertTrue(mock_logger_error.called)
 653
 654     def test_get_availability_zone_names_default(self):
 655         with mock.patch('functest.utils.openstack_utils'
 656                         '.get_availability_zones',
 657                         return_value=[self.availability_zone]):
 658             self.assertEqual(openstack_utils.
 659                              get_availability_zone_names(self.nova_client),
 660                              ['test_azone'])
 661
 662     @mock.patch('functest.utils.openstack_utils.logger.error')
 663     def test_get_availability_zone_names_exception(self, mock_logger_error):
 664             self.assertEqual(openstack_utils.
 665                              get_availability_zone_names(Exception),
 666                              None)
 667             self.assertTrue(mock_logger_error.called)
 668
 669     def test_get_availability_zones_default(self):
 670             self.assertEqual(openstack_utils.
 671                              get_availability_zones(self.nova_client),
 672                              [self.availability_zone])
 673
 674     @mock.patch('functest.utils.openstack_utils.logger.error')
 675     def test_get_availability_zones_exception(self, mock_logger_error):
 676             self.assertEqual(openstack_utils.
 677                              get_availability_zones(Exception),
 678                              None)
 679             self.assertTrue(mock_logger_error.called)
 680
 681     def test_get_floating_ips_default(self):
 682             self.assertEqual(openstack_utils.
 683                              get_floating_ips(self.neutron_client),
 684                              [self.floating_ip])
 685
 686     @mock.patch('functest.utils.openstack_utils.logger.error')
 687     def test_get_floating_ips_exception(self, mock_logger_error):
 688             self.assertEqual(openstack_utils.
 689                              get_floating_ips(Exception),
 690                              None)
 691             self.assertTrue(mock_logger_error.called)
 692
 693     def test_get_hypervisors_default(self):
 694             self.assertEqual(openstack_utils.
 695                              get_hypervisors(self.nova_client),
 696                              ['test_hostname'])
 697
 698     @mock.patch('functest.utils.openstack_utils.logger.error')
 699     def test_get_hypervisors_exception(self, mock_logger_error):
 700             self.assertEqual(openstack_utils.
 701                              get_hypervisors(Exception),
 702                              None)
 703             self.assertTrue(mock_logger_error.called)
 704
 705     def test_create_aggregate_default(self):
 706             self.assertTrue(openstack_utils.
 707                             create_aggregate(self.nova_client,
 708                                              'test_aggregate',
 709                                              'azone'))
 710
 711     @mock.patch('functest.utils.openstack_utils.logger.error')
 712     def test_create_aggregate_exception(self, mock_logger_error):
 713             self.assertEqual(openstack_utils.
 714                              create_aggregate(Exception,
 715                                               'test_aggregate',
 716                                               'azone'),
 717                              None)
 718             self.assertTrue(mock_logger_error.called)
 719
 720     def test_add_host_to_aggregate_default(self):
 721         with mock.patch('functest.utils.openstack_utils.get_aggregate_id'):
 722                 self.assertTrue(openstack_utils.
 723                                 add_host_to_aggregate(self.nova_client,
 724                                                       'test_aggregate',
 725                                                       'test_hostname'))
 726
 727     @mock.patch('functest.utils.openstack_utils.logger.error')
 728     def test_add_host_to_aggregate_exception(self, mock_logger_error):
 729             self.assertEqual(openstack_utils.
 730                              add_host_to_aggregate(Exception,
 731                                                    'test_aggregate',
 732                                                    'test_hostname'),
 733                              None)
 734             self.assertTrue(mock_logger_error.called)
 735
 736     def test_create_aggregate_with_host_default(self):
 737         with mock.patch('functest.utils.openstack_utils.create_aggregate'), \
 738                 mock.patch('functest.utils.openstack_utils.'
 739                            'add_host_to_aggregate'):
 740             self.assertTrue(openstack_utils.
 741                             create_aggregate_with_host(self.nova_client,
 742                                                        'test_aggregate',
 743                                                        'test_azone',
 744                                                        'test_hostname'))
 745
 746     @mock.patch('functest.utils.openstack_utils.logger.error')
 747     def test_create_aggregate_with_host_exception(self, mock_logger_error):
 748             with mock.patch('functest.utils.openstack_utils.create_aggregate',
 749                             side_effect=Exception):
 750                 self.assertEqual(openstack_utils.
 751                                  create_aggregate_with_host(Exception,
 752                                                             'test_aggregate',
 753                                                             'test_azone',
 754                                                             'test_hostname'),
 755                                  None)
 756                 self.assertTrue(mock_logger_error.called)
 757
 758     def test_create_instance_default(self):
 759         with mock.patch('functest.utils.openstack_utils.'
 760                         'get_nova_client',
 761                         return_value=self.nova_client):
 762             self.assertEqual(openstack_utils.
 763                              create_instance('test_flavor',
 764                                              'image_id',
 765                                              'network_id'),
 766                              self.instance)
 767
 768     @mock.patch('functest.utils.openstack_utils.logger.error')
 769     def test_create_instance_exception(self, mock_logger_error):
 770         with mock.patch('functest.utils.openstack_utils.'
 771                         'get_nova_client',
 772                         return_value=self.nova_client):
 773             self.nova_client.flavors.find.side_effect = Exception
 774             self.assertEqual(openstack_utils.
 775                              create_instance('test_flavor',
 776                                              'image_id',
 777                                              'network_id'),
 778                              None)
 779             self.assertTrue(mock_logger_error)
 780
 781     def test_create_floating_ip_default(self):
 782         with mock.patch('functest.utils.openstack_utils.'
 783                         'get_external_net_id',
 784                         return_value='external_net_id'):
 785             exp_resp = {'fip_addr': 'test_ip', 'fip_id': 'fip_id'}
 786             self.assertEqual(openstack_utils.
 787                              create_floating_ip(self.neutron_client),
 788                              exp_resp)
 789
 790     @mock.patch('functest.utils.openstack_utils.logger.error')
 791     def test_create_floating_ip_exception(self, mock_logger_error):
 792         with mock.patch('functest.utils.openstack_utils.'
 793                         'get_external_net_id',
 794                         return_value='external_net_id'):
 795             self.assertEqual(openstack_utils.
 796                              create_floating_ip(Exception),
 797                              None)
 798             self.assertTrue(mock_logger_error)
 799
 800     def test_add_floating_ip_default(self):
 801         with mock.patch('functest.utils.openstack_utils.get_aggregate_id'):
 802                 self.assertTrue(openstack_utils.
 803                                 add_floating_ip(self.nova_client,
 804                                                 'test_serverid',
 805                                                 'test_floatingip_addr'))
 806
 807     @mock.patch('functest.utils.openstack_utils.logger.error')
 808     def test_add_floating_ip_exception(self, mock_logger_error):
 809             self.assertFalse(openstack_utils.
 810                              add_floating_ip(Exception,
 811                                              'test_serverid',
 812                                              'test_floatingip_addr'))
 813             self.assertTrue(mock_logger_error.called)
 814
 815     def test_delete_instance_default(self):
 816             self.assertTrue(openstack_utils.
 817                             delete_instance(self.nova_client,
 818                                             'instance_id'))
 819
 820     @mock.patch('functest.utils.openstack_utils.logger.error')
 821     def test_delete_instance_exception(self, mock_logger_error):
 822             self.assertFalse(openstack_utils.
 823                              delete_instance(Exception,
 824                                              'instance_id'))
 825             self.assertTrue(mock_logger_error.called)
 826
 827     def test_delete_floating_ip_default(self):
 828             self.assertTrue(openstack_utils.
 829                             delete_floating_ip(self.neutron_client,
 830                                                'floating_ip_id'))
 831
 832     @mock.patch('functest.utils.openstack_utils.logger.error')
 833     def test_delete_floating_ip_exception(self, mock_logger_error):
 834             self.assertFalse(openstack_utils.
 835                              delete_floating_ip(Exception,
 836                                                 'floating_ip_id'))
 837             self.assertTrue(mock_logger_error.called)
 838
 839     def test_remove_host_from_aggregate_default(self):
 840         with mock.patch('functest.utils.openstack_utils.'
 841                         'get_aggregate_id'):
 842                 self.assertTrue(openstack_utils.
 843                                 remove_host_from_aggregate(self.nova_client,
 844                                                            'agg_name',
 845                                                            'host_name'))
 846
 847     @mock.patch('functest.utils.openstack_utils.logger.error')
 848     def test_remove_host_from_aggregate_exception(self, mock_logger_error):
 849         with mock.patch('functest.utils.openstack_utils.'
 850                         'get_aggregate_id', side_effect=Exception):
 851             self.assertFalse(openstack_utils.
 852                              remove_host_from_aggregate(self.nova_client,
 853                                                         'agg_name',
 854                                                         'host_name'))
 855             self.assertTrue(mock_logger_error.called)
 856
 857     def test_remove_hosts_from_aggregate_default(self):
 858         with mock.patch('functest.utils.openstack_utils.'
 859                         'get_aggregate_id'), \
 860             mock.patch('functest.utils.openstack_utils.'
 861                        'remove_host_from_aggregate',
 862                        return_value=True) \
 863                 as mock_method:
 864             openstack_utils.remove_hosts_from_aggregate(self.nova_client,
 865                                                         'test_aggregate')
 866             mock_method.assert_any_call(self.nova_client,
 867                                         'test_aggregate',
 868                                         'host_name')
 869
 870     def test_delete_aggregate_default(self):
 871         with mock.patch('functest.utils.openstack_utils.'
 872                         'remove_hosts_from_aggregate'):
 873                 self.assertTrue(openstack_utils.
 874                                 delete_aggregate(self.nova_client,
 875                                                  'agg_name'))
 876
 877     @mock.patch('functest.utils.openstack_utils.logger.error')
 878     def test_delete_aggregate_exception(self, mock_logger_error):
 879         with mock.patch('functest.utils.openstack_utils.'
 880                         'remove_hosts_from_aggregate', side_effect=Exception):
 881             self.assertFalse(openstack_utils.
 882                              delete_aggregate(self.nova_client,
 883                                               'agg_name'))
 884             self.assertTrue(mock_logger_error.called)
 885
 886     def test_get_network_list_default(self):
 887         self.assertEqual(openstack_utils.
 888                          get_network_list(self.neutron_client),
 889                          self.networks)
 890
 891     def test_get_network_list_missing_network(self):
 892         self.assertEqual(openstack_utils.
 893                          get_network_list(self.empty_client),
 894                          None)
 895
 896     def test_get_router_list_default(self):
 897         self.assertEqual(openstack_utils.
 898                          get_router_list(self.neutron_client),
 899                          [self.router])
 900
 901     def test_get_router_list_missing_router(self):
 902         self.assertEqual(openstack_utils.
 903                          get_router_list(self.empty_client),
 904                          None)
 905
 906     def test_get_port_list_default(self):
 907         self.assertEqual(openstack_utils.
 908                          get_port_list(self.neutron_client),
 909                          [self.port])
 910
 911     def test_get_port_list_missing_port(self):
 912         self.assertEqual(openstack_utils.
 913                          get_port_list(self.empty_client),
 914                          None)
 915
 916     def test_get_network_id_default(self):
 917         self.assertEqual(openstack_utils.
 918                          get_network_id(self.neutron_client,
 919                                         'test_network'),
 920                          'network_id')
 921
 922     def test_get_subnet_id_default(self):
 923         self.assertEqual(openstack_utils.
 924                          get_subnet_id(self.neutron_client,
 925                                        'test_subnet'),
 926                          'subnet_id')
 927
 928     def test_get_router_id_default(self):
 929         self.assertEqual(openstack_utils.
 930                          get_router_id(self.neutron_client,
 931                                        'test_router'),
 932                          'router_id')
 933
 934     def test_get_private_net_default(self):
 935         self.assertEqual(openstack_utils.
 936                          get_private_net(self.neutron_client),
 937                          self.networks[0])
 938
 939     def test_get_private_net_missing_net(self):
 940         self.assertEqual(openstack_utils.
 941                          get_private_net(self.empty_client),
 942                          None)
 943
 944     def test_get_external_net_default(self):
 945         self.assertEqual(openstack_utils.
 946                          get_external_net(self.neutron_client),
 947                          'test_network1')
 948
 949     def test_get_external_net_missing_net(self):
 950         self.assertEqual(openstack_utils.
 951                          get_external_net(self.empty_client),
 952                          None)
 953
 954     def test_get_external_net_id_default(self):
 955         self.assertEqual(openstack_utils.
 956                          get_external_net_id(self.neutron_client),
 957                          'network_id1')
 958
 959     def test_get_external_net_id_missing_net(self):
 960         self.assertEqual(openstack_utils.
 961                          get_external_net_id(self.empty_client),
 962                          None)
 963
 964     def test_check_neutron_net_default(self):
 965         self.assertTrue(openstack_utils.
 966                         check_neutron_net(self.neutron_client,
 967                                           'test_network'))
 968
 969     def test_check_neutron_net_missing_net(self):
 970         self.assertFalse(openstack_utils.
 971                          check_neutron_net(self.empty_client,
 972                                            'test_network'))
 973
 974     def test_create_neutron_net_default(self):
 975             self.assertEqual(openstack_utils.
 976                              create_neutron_net(self.neutron_client,
 977                                                 'test_network'),
 978                              'network_id')
 979
 980     @mock.patch('functest.utils.openstack_utils.logger.error')
 981     def test_create_neutron_net_exception(self, mock_logger_error):
 982             self.assertEqual(openstack_utils.
 983                              create_neutron_net(Exception,
 984                                                 'test_network'),
 985                              None)
 986             self.assertTrue(mock_logger_error.called)
 987
 988     def test_create_neutron_subnet_default(self):
 989             self.assertEqual(openstack_utils.
 990                              create_neutron_subnet(self.neutron_client,
 991                                                    'test_subnet',
 992                                                    'test_cidr',
 993                                                    'network_id'),
 994                              'subnet_id')
 995
 996     @mock.patch('functest.utils.openstack_utils.logger.error')
 997     def test_create_neutron_subnet_exception(self, mock_logger_error):
 998             self.assertEqual(openstack_utils.
 999                              create_neutron_subnet(Exception,
1000                                                    'test_subnet',
1001                                                    'test_cidr',
1002                                                    'network_id'),
1003                              None)
1004             self.assertTrue(mock_logger_error.called)
1005
1006     def test_create_neutron_router_default(self):
1007             self.assertEqual(openstack_utils.
1008                              create_neutron_router(self.neutron_client,
1009                                                    'test_router'),
1010                              'router_id')
1011
1012     @mock.patch('functest.utils.openstack_utils.logger.error')
1013     def test_create_neutron_router_exception(self, mock_logger_error):
1014             self.assertEqual(openstack_utils.
1015                              create_neutron_router(Exception,
1016                                                    'test_router'),
1017                              None)
1018             self.assertTrue(mock_logger_error.called)
1019
1020     def test_create_neutron_port_default(self):
1021             self.assertEqual(openstack_utils.
1022                              create_neutron_port(self.neutron_client,
1023                                                  'test_port',
1024                                                  'network_id',
1025                                                  'test_ip'),
1026                              'port_id')
1027
1028     @mock.patch('functest.utils.openstack_utils.logger.error')
1029     def test_create_neutron_port_exception(self, mock_logger_error):
1030             self.assertEqual(openstack_utils.
1031                              create_neutron_port(Exception,
1032                                                  'test_port',
1033                                                  'network_id',
1034                                                  'test_ip'),
1035                              None)
1036             self.assertTrue(mock_logger_error.called)
1037
1038     def test_update_neutron_net_default(self):
1039             self.assertTrue(openstack_utils.
1040                             update_neutron_net(self.neutron_client,
1041                                                'network_id'))
1042
1043     @mock.patch('functest.utils.openstack_utils.logger.error')
1044     def test_update_neutron_net_exception(self, mock_logger_error):
1045             self.assertFalse(openstack_utils.
1046                              update_neutron_net(Exception,
1047                                                 'network_id'))
1048             self.assertTrue(mock_logger_error.called)
1049
1050     def test_update_neutron_port_default(self):
1051             self.assertEqual(openstack_utils.
1052                              update_neutron_port(self.neutron_client,
1053                                                  'port_id',
1054                                                  'test_owner'),
1055                              'port_id')
1056
1057     @mock.patch('functest.utils.openstack_utils.logger.error')
1058     def test_update_neutron_port_exception(self, mock_logger_error):
1059             self.assertEqual(openstack_utils.
1060                              update_neutron_port(Exception,
1061                                                  'port_id',
1062                                                  'test_owner'),
1063                              None)
1064             self.assertTrue(mock_logger_error.called)
1065
1066     def test_add_interface_router_default(self):
1067             self.assertTrue(openstack_utils.
1068                             add_interface_router(self.neutron_client,
1069                                                  'router_id',
1070                                                  'subnet_id'))
1071
1072     @mock.patch('functest.utils.openstack_utils.logger.error')
1073     def test_add_interface_router_exception(self, mock_logger_error):
1074             self.assertFalse(openstack_utils.
1075                              add_interface_router(Exception,
1076                                                   'router_id',
1077                                                   'subnet_id'))
1078             self.assertTrue(mock_logger_error.called)
1079
1080     def test_add_gateway_router_default(self):
1081         with mock.patch('functest.utils.openstack_utils.'
1082                         'get_external_net_id',
1083                         return_value='network_id'):
1084                 self.assertTrue(openstack_utils.
1085                                 add_gateway_router(self.neutron_client,
1086                                                    'router_id'))
1087
1088     @mock.patch('functest.utils.openstack_utils.logger.error')
1089     def test_add_gateway_router_exception(self, mock_logger_error):
1090         with mock.patch('functest.utils.openstack_utils.'
1091                         'get_external_net_id',
1092                         return_value='network_id'):
1093                 self.assertFalse(openstack_utils.
1094                                  add_gateway_router(Exception,
1095                                                     'router_id'))
1096                 self.assertTrue(mock_logger_error.called)
1097
1098     def test_delete_neutron_net_default(self):
1099             self.assertTrue(openstack_utils.
1100                             delete_neutron_net(self.neutron_client,
1101                                                'network_id'))
1102
1103     @mock.patch('functest.utils.openstack_utils.logger.error')
1104     def test_delete_neutron_net_exception(self, mock_logger_error):
1105             self.assertFalse(openstack_utils.
1106                              delete_neutron_net(Exception,
1107                                                 'network_id'))
1108             self.assertTrue(mock_logger_error.called)
1109
1110     def test_delete_neutron_subnet_default(self):
1111             self.assertTrue(openstack_utils.
1112                             delete_neutron_subnet(self.neutron_client,
1113                                                   'subnet_id'))
1114
1115     @mock.patch('functest.utils.openstack_utils.logger.error')
1116     def test_delete_neutron_subnet_exception(self, mock_logger_error):
1117             self.assertFalse(openstack_utils.
1118                              delete_neutron_subnet(Exception,
1119                                                    'subnet_id'))
1120             self.assertTrue(mock_logger_error.called)
1121
1122     def test_delete_neutron_router_default(self):
1123             self.assertTrue(openstack_utils.
1124                             delete_neutron_router(self.neutron_client,
1125                                                   'router_id'))
1126
1127     @mock.patch('functest.utils.openstack_utils.logger.error')
1128     def test_delete_neutron_router_exception(self, mock_logger_error):
1129             self.assertFalse(openstack_utils.
1130                              delete_neutron_router(Exception,
1131                                                    'router_id'))
1132             self.assertTrue(mock_logger_error.called)
1133
1134     def test_delete_neutron_port_default(self):
1135             self.assertTrue(openstack_utils.
1136                             delete_neutron_port(self.neutron_client,
1137                                                 'port_id'))
1138
1139     @mock.patch('functest.utils.openstack_utils.logger.error')
1140     def test_delete_neutron_port_exception(self, mock_logger_error):
1141             self.assertFalse(openstack_utils.
1142                              delete_neutron_port(Exception,
1143                                                  'port_id'))
1144             self.assertTrue(mock_logger_error.called)
1145
1146     def test_remove_interface_router_default(self):
1147             self.assertTrue(openstack_utils.
1148                             remove_interface_router(self.neutron_client,
1149                                                     'router_id',
1150                                                     'subnet_id'))
1151
1152     @mock.patch('functest.utils.openstack_utils.logger.error')
1153     def test_remove_interface_router_exception(self, mock_logger_error):
1154             self.assertFalse(openstack_utils.
1155                              remove_interface_router(Exception,
1156                                                      'router_id',
1157                                                      'subnet_id'))
1158             self.assertTrue(mock_logger_error.called)
1159
1160     def test_remove_gateway_router_default(self):
1161             self.assertTrue(openstack_utils.
1162                             remove_gateway_router(self.neutron_client,
1163                                                   'router_id'))
1164
1165     @mock.patch('functest.utils.openstack_utils.logger.error')
1166     def test_remove_gateway_router_exception(self, mock_logger_error):
1167             self.assertFalse(openstack_utils.
1168                              remove_gateway_router(Exception,
1169                                                    'router_id'))
1170             self.assertTrue(mock_logger_error.called)
1171
1172     def test_get_security_groups_default(self):
1173         self.assertEqual(openstack_utils.
1174                          get_security_groups(self.neutron_client),
1175                          [self.sec_group])
1176
1177     @mock.patch('functest.utils.openstack_utils.logger.error')
1178     def test_get_security_groups_exception(self, mock_logger_error):
1179         self.assertEqual(openstack_utils.
1180                          get_security_groups(Exception),
1181                          None)
1182         self.assertTrue(mock_logger_error.called)
1183
1184     def test_get_security_group_id_default(self):
1185         with mock.patch('functest.utils.openstack_utils.'
1186                         'get_security_groups',
1187                         return_value=[self.sec_group]):
1188             self.assertEqual(openstack_utils.
1189                              get_security_group_id(self.neutron_client,
1190                                                    'test_sec_group'),
1191                              'sec_group_id')
1192
1193     def test_get_security_group_rules_default(self):
1194         self.assertEqual(openstack_utils.
1195                          get_security_group_rules(self.neutron_client,
1196                                                   self.sec_group['id']),
1197                          [self.sec_group_rule])
1198
1199     @mock.patch('functest.utils.openstack_utils.logger.error')
1200     def test_get_security_group_rules_exception(self, mock_logger_error):
1201         self.assertEqual(openstack_utils.
1202                          get_security_group_rules(Exception,
1203                                                   'sec_group_id'),
1204                          None)
1205         self.assertTrue(mock_logger_error.called)
1206
1207     def test_check_security_group_rules_not_exists(self):
1208         self.assertEqual(openstack_utils.
1209                          check_security_group_rules(self.neutron_client,
1210                                                     'sec_group_id_2',
1211                                                     'direction',
1212                                                     'protocol',
1213                                                     'port_min',
1214                                                     'port_max'),
1215                          True)
1216
1217     def test_check_security_group_rules_exists(self):
1218         self.assertEqual(openstack_utils.
1219                          check_security_group_rules(self.neutron_client,
1220                                                     self.sec_group['id'],
1221                                                     'direction',
1222                                                     'protocol',
1223                                                     'port_min',
1224                                                     'port_max'),
1225                          False)
1226
1227     @mock.patch('functest.utils.openstack_utils.logger.error')
1228     def test_check_security_group_rules_exception(self, mock_logger_error):
1229         self.assertEqual(openstack_utils.
1230                          check_security_group_rules(Exception,
1231                                                     'sec_group_id',
1232                                                     'direction',
1233                                                     'protocol',
1234                                                     'port_max',
1235                                                     'port_min'),
1236                          None)
1237         self.assertTrue(mock_logger_error.called)
1238
1239     def test_create_security_group_default(self):
1240         self.assertEqual(openstack_utils.
1241                          create_security_group(self.neutron_client,
1242                                                'test_sec_group',
1243                                                'sec_group_desc'),
1244                          self.sec_group)
1245
1246     @mock.patch('functest.utils.openstack_utils.logger.error')
1247     def test_create_security_group_exception(self, mock_logger_error):
1248         self.assertEqual(openstack_utils.
1249                          create_security_group(Exception,
1250                                                'test_sec_group',
1251                                                'sec_group_desc'),
1252                          None)
1253         self.assertTrue(mock_logger_error.called)
1254
1255     def test_create_secgroup_rule_default(self):
1256         self.assertTrue(openstack_utils.
1257                         create_secgroup_rule(self.neutron_client,
1258                                              'sg_id',
1259                                              'direction',
1260                                              'protocol',
1261                                              80,
1262                                              80))
1263         self.assertTrue(openstack_utils.
1264                         create_secgroup_rule(self.neutron_client,
1265                                              'sg_id',
1266                                              'direction',
1267                                              'protocol'))
1268
1269     @mock.patch('functest.utils.openstack_utils.logger.error')
1270     def test_create_secgroup_rule_invalid_port_range(self, mock_logger_error):
1271         self.assertFalse(openstack_utils.
1272                          create_secgroup_rule(self.neutron_client,
1273                                               'sg_id',
1274                                               'direction',
1275                                               'protocol',
1276                                               80))
1277
1278     @mock.patch('functest.utils.openstack_utils.logger.error')
1279     def test_create_secgroup_rule_exception(self, mock_logger_error):
1280         self.assertFalse(openstack_utils.
1281                          create_secgroup_rule(Exception,
1282                                               'sg_id',
1283                                               'direction',
1284                                               'protocol'))
1285
1286     @mock.patch('functest.utils.openstack_utils.logger.info')
1287     def test_create_security_group_full_default(self, mock_logger_info):
1288         with mock.patch('functest.utils.openstack_utils.'
1289                         'get_security_group_id',
1290                         return_value='sg_id'):
1291             self.assertEqual(openstack_utils.
1292                              create_security_group_full(self.neutron_client,
1293                                                         'sg_name',
1294                                                         'sg_desc'),
1295                              'sg_id')
1296             self.assertTrue(mock_logger_info)
1297
1298     @mock.patch('functest.utils.openstack_utils.logger.info')
1299     @mock.patch('functest.utils.openstack_utils.logger.error')
1300     def test_create_security_group_full_sec_group_fail(self,
1301                                                        mock_logger_error,
1302                                                        mock_logger_info):
1303         with mock.patch('functest.utils.openstack_utils.'
1304                         'get_security_group_id',
1305                         return_value=''), \
1306             mock.patch('functest.utils.openstack_utils.'
1307                        'create_security_group',
1308                        return_value=False):
1309             self.assertEqual(openstack_utils.
1310                              create_security_group_full(self.neutron_client,
1311                                                         'sg_name',
1312                                                         'sg_desc'),
1313                              None)
1314             self.assertTrue(mock_logger_error)
1315             self.assertTrue(mock_logger_info)
1316
1317     @mock.patch('functest.utils.openstack_utils.logger.debug')
1318     @mock.patch('functest.utils.openstack_utils.logger.info')
1319     @mock.patch('functest.utils.openstack_utils.logger.error')
1320     def test_create_security_group_full_secgroup_rule_fail(self,
1321                                                            mock_logger_error,
1322                                                            mock_logger_info,
1323                                                            mock_logger_debug):
1324         with mock.patch('functest.utils.openstack_utils.'
1325                         'get_security_group_id',
1326                         return_value=''), \
1327             mock.patch('functest.utils.openstack_utils.'
1328                        'create_security_group',
1329                        return_value={'id': 'sg_id',
1330                                      'name': 'sg_name'}), \
1331             mock.patch('functest.utils.openstack_utils.'
1332                        'create_secgroup_rule',
1333                        return_value=False):
1334             self.assertEqual(openstack_utils.
1335                              create_security_group_full(self.neutron_client,
1336                                                         'sg_name',
1337                                                         'sg_desc'),
1338                              None)
1339             self.assertTrue(mock_logger_error)
1340             self.assertTrue(mock_logger_info)
1341             self.assertTrue(mock_logger_debug)
1342
1343     def test_add_secgroup_to_instance_default(self):
1344         self.assertTrue(openstack_utils.
1345                         add_secgroup_to_instance(self.nova_client,
1346                                                  'instance_id',
1347                                                  'sec_group_id'))
1348
1349     @mock.patch('functest.utils.openstack_utils.logger.error')
1350     def test_add_secgroup_to_instance_exception(self, mock_logger_error):
1351         self.assertFalse(openstack_utils.
1352                          add_secgroup_to_instance(Exception,
1353                                                   'instance_id',
1354                                                   'sec_group_id'))
1355         self.assertTrue(mock_logger_error.called)
1356
1357     def test_update_sg_quota_default(self):
1358         self.assertTrue(openstack_utils.
1359                         update_sg_quota(self.neutron_client,
1360                                         'tenant_id',
1361                                         'sg_quota',
1362                                         'sg_rule_quota'))
1363
1364     @mock.patch('functest.utils.openstack_utils.logger.error')
1365     def test_update_sg_quota_exception(self, mock_logger_error):
1366         self.assertFalse(openstack_utils.
1367                          update_sg_quota(Exception,
1368                                          'tenant_id',
1369                                          'sg_quota',
1370                                          'sg_rule_quota'))
1371         self.assertTrue(mock_logger_error.called)
1372
1373     def test_delete_security_group_default(self):
1374         self.assertTrue(openstack_utils.
1375                         delete_security_group(self.neutron_client,
1376                                               'sec_group_id'))
1377
1378     @mock.patch('functest.utils.openstack_utils.logger.error')
1379     def test_delete_security_group_exception(self, mock_logger_error):
1380         self.assertFalse(openstack_utils.
1381                          delete_security_group(Exception,
1382                                                'sec_group_id'))
1383         self.assertTrue(mock_logger_error.called)
1384
1385     def test_get_images_default(self):
1386         self.assertEqual(openstack_utils.
1387                          get_images(self.glance_client),
1388                          [self.image])
1389
1390     @mock.patch('functest.utils.openstack_utils.logger.error')
1391     def test_get_images_exception(self, mock_logger_error):
1392         self.assertEqual(openstack_utils.
1393                          get_images(Exception),
1394                          None)
1395         self.assertTrue(mock_logger_error.called)
1396
1397     def test_get_image_id_default(self):
1398         self.assertEqual(openstack_utils.
1399                          get_image_id(self.glance_client,
1400                                       'test_image'),
1401                          'image_id')
1402
1403     # create_glance_image, get_or_create_image
1404     @mock.patch('functest.utils.openstack_utils.logger.error')
1405     def test_create_glance_image_file_present(self, mock_logger_error):
1406         with mock.patch('functest.utils.openstack_utils.'
1407                         'os.path.isfile',
1408                         return_value=False):
1409             self.assertEqual(openstack_utils.
1410                              create_glance_image(self.glance_client,
1411                                                  'test_image',
1412                                                  'file_path'),
1413                              None)
1414             self.assertTrue(mock_logger_error.called)
1415
1416     @mock.patch('functest.utils.openstack_utils.logger.info')
1417     def test_create_glance_image_already_exist(self, mock_logger_info):
1418         with mock.patch('functest.utils.openstack_utils.'
1419                         'os.path.isfile',
1420                         return_value=True), \
1421             mock.patch('functest.utils.openstack_utils.get_image_id',
1422                        return_value='image_id'):
1423                 self.assertEqual(openstack_utils.
1424                                  create_glance_image(self.glance_client,
1425                                                      'test_image',
1426                                                      'file_path'),
1427                                  'image_id')
1428                 self.assertTrue(mock_logger_info.called)
1429
1430     @mock.patch('functest.utils.openstack_utils.logger.info')
1431     def test_create_glance_image_default(self, mock_logger_info):
1432         with mock.patch('functest.utils.openstack_utils.'
1433                         'os.path.isfile',
1434                         return_value=True), \
1435             mock.patch('functest.utils.openstack_utils.get_image_id',
1436                        return_value=''), \
1437             mock.patch('six.moves.builtins.open',
1438                        mock.mock_open(read_data='1')) as m:
1439                 self.assertEqual(openstack_utils.
1440                                  create_glance_image(self.glance_client,
1441                                                      'test_image',
1442                                                      'file_path'),
1443                                  'image_id')
1444                 m.assert_called_once_with('file_path')
1445                 self.assertTrue(mock_logger_info.called)
1446
1447     @mock.patch('functest.utils.openstack_utils.logger.error')
1448     def test_create_glance_image_exception(self, mock_logger_error):
1449         with mock.patch('functest.utils.openstack_utils.'
1450                         'os.path.isfile',
1451                         return_value=True), \
1452             mock.patch('functest.utils.openstack_utils.get_image_id',
1453                        side_effect=Exception):
1454                 self.assertEqual(openstack_utils.
1455                                  create_glance_image(self.glance_client,
1456                                                      'test_image',
1457                                                      'file_path'),
1458                                  None)
1459                 self.assertTrue(mock_logger_error.called)
1460
1461     def test_delete_glance_image_default(self):
1462         self.assertTrue(openstack_utils.
1463                         delete_glance_image(self.nova_client,
1464                                             'image_id'))
1465
1466     @mock.patch('functest.utils.openstack_utils.logger.error')
1467     def test_delete_glance_image_exception(self, mock_logger_error):
1468         self.assertFalse(openstack_utils.
1469                          delete_glance_image(Exception,
1470                                              'image_id'))
1471         self.assertTrue(mock_logger_error.called)
1472
1473     def test_get_volumes_default(self):
1474         self.assertEqual(openstack_utils.
1475                          get_volumes(self.cinder_client),
1476                          [self.volume])
1477
1478     @mock.patch('functest.utils.openstack_utils.logger.error')
1479     def test_get_volumes_exception(self, mock_logger_error):
1480         self.assertEqual(openstack_utils.
1481                          get_volumes(Exception),
1482                          None)
1483         self.assertTrue(mock_logger_error.called)
1484
1485     def test_update_cinder_quota_default(self):
1486         self.assertTrue(openstack_utils.
1487                         update_cinder_quota(self.cinder_client,
1488                                             'tenant_id',
1489                                             'vols_quota',
1490                                             'snap_quota',
1491                                             'giga_quota'))
1492
1493     @mock.patch('functest.utils.openstack_utils.logger.error')
1494     def test_update_cinder_quota_exception(self, mock_logger_error):
1495         self.assertFalse(openstack_utils.
1496                          update_cinder_quota(Exception,
1497                                              'tenant_id',
1498                                              'vols_quota',
1499                                              'snap_quota',
1500                                              'giga_quota'))
1501         self.assertTrue(mock_logger_error.called)
1502
1503     def test_delete_volume_default(self):
1504         self.assertTrue(openstack_utils.
1505                         delete_volume(self.cinder_client,
1506                                       'volume_id',
1507                                       forced=False))
1508
1509         self.assertTrue(openstack_utils.
1510                         delete_volume(self.cinder_client,
1511                                       'volume_id',
1512                                       forced=True))
1513
1514     @mock.patch('functest.utils.openstack_utils.logger.error')
1515     def test_delete_volume_exception(self, mock_logger_error):
1516         self.assertFalse(openstack_utils.
1517                          delete_volume(Exception,
1518                                        'volume_id',
1519                                        forced=True))
1520         self.assertTrue(mock_logger_error.called)
1521
1522     def test_get_tenants_default(self):
1523         with mock.patch('functest.utils.openstack_utils.'
1524                         'is_keystone_v3', return_value=True):
1525             self.assertEqual(openstack_utils.
1526                              get_tenants(self.keystone_client),
1527                              [self.tenant])
1528         with mock.patch('functest.utils.openstack_utils.'
1529                         'is_keystone_v3', return_value=False):
1530             self.assertEqual(openstack_utils.
1531                              get_tenants(self.keystone_client),
1532                              [self.tenant])
1533
1534     @mock.patch('functest.utils.openstack_utils.logger.error')
1535     def test_get_tenants_exception(self, mock_logger_error):
1536         self.assertEqual(openstack_utils.
1537                          get_tenants(Exception),
1538                          None)
1539         self.assertTrue(mock_logger_error.called)
1540
1541     def test_get_users_default(self):
1542         self.assertEqual(openstack_utils.
1543                          get_users(self.keystone_client),
1544                          [self.user])
1545
1546     @mock.patch('functest.utils.openstack_utils.logger.error')
1547     def test_get_users_exception(self, mock_logger_error):
1548         self.assertEqual(openstack_utils.
1549                          get_users(Exception),
1550                          None)
1551         self.assertTrue(mock_logger_error.called)
1552
1553     def test_get_tenant_id_default(self):
1554         self.assertEqual(openstack_utils.
1555                          get_tenant_id(self.keystone_client,
1556                                        'test_tenant'),
1557                          'tenant_id')
1558
1559     def test_get_user_id_default(self):
1560         self.assertEqual(openstack_utils.
1561                          get_user_id(self.keystone_client,
1562                                      'test_user'),
1563                          'user_id')
1564
1565     def test_get_role_id_default(self):
1566         self.assertEqual(openstack_utils.
1567                          get_role_id(self.keystone_client,
1568                                      'test_role'),
1569                          'role_id')
1570
1571     def test_get_domain_id_default(self):
1572         self.assertEqual(openstack_utils.
1573                          get_domain_id(self.keystone_client,
1574                                        'test_domain'),
1575                          'domain_id')
1576
1577     def test_create_tenant_default(self):
1578         with mock.patch('functest.utils.openstack_utils.'
1579                         'is_keystone_v3', return_value=True):
1580             os.environ['OS_PROJECT_DOMAIN_NAME'] = 'Default'
1581             self.assertEqual(openstack_utils.
1582                              create_tenant(self.keystone_client,
1583                                            'test_tenant',
1584                                            'tenant_desc'),
1585                              'tenant_id')
1586         with mock.patch('functest.utils.openstack_utils.'
1587                         'is_keystone_v3', return_value=False):
1588             self.assertEqual(openstack_utils.
1589                              create_tenant(self.keystone_client,
1590                                            'test_tenant',
1591                                            'tenant_desc'),
1592                              'tenant_id')
1593
1594     @mock.patch('functest.utils.openstack_utils.logger.error')
1595     def test_create_tenant_exception(self, mock_logger_error):
1596         self.assertEqual(openstack_utils.
1597                          create_tenant(Exception,
1598                                        'test_tenant',
1599                                        'tenant_desc'),
1600                          None)
1601         self.assertTrue(mock_logger_error.called)
1602
1603     def test_create_user_default(self):
1604         with mock.patch('functest.utils.openstack_utils.'
1605                         'is_keystone_v3', return_value=True):
1606             self.assertEqual(openstack_utils.
1607                              create_user(self.keystone_client,
1608                                          'test_user',
1609                                          'password',
1610                                          'email',
1611                                          'tenant_id'),
1612                              'user_id')
1613         with mock.patch('functest.utils.openstack_utils.'
1614                         'is_keystone_v3', return_value=False):
1615             self.assertEqual(openstack_utils.
1616                              create_user(self.keystone_client,
1617                                          'test_user',
1618                                          'password',
1619                                          'email',
1620                                          'tenant_id'),
1621                              'user_id')
1622
1623     @mock.patch('functest.utils.openstack_utils.logger.error')
1624     def test_create_user_exception(self, mock_logger_error):
1625         self.assertEqual(openstack_utils.
1626                          create_user(Exception,
1627                                      'test_user',
1628                                      'password',
1629                                      'email',
1630                                      'tenant_id'),
1631                          None)
1632         self.assertTrue(mock_logger_error.called)
1633
1634     def test_add_role_user_default(self):
1635         with mock.patch('functest.utils.openstack_utils.'
1636                         'is_keystone_v3', return_value=True):
1637             self.assertTrue(openstack_utils.
1638                             add_role_user(self.keystone_client,
1639                                           'user_id',
1640                                           'role_id',
1641                                           'tenant_id'))
1642
1643         with mock.patch('functest.utils.openstack_utils.'
1644                         'is_keystone_v3', return_value=False):
1645             self.assertTrue(openstack_utils.
1646                             add_role_user(self.keystone_client,
1647                                           'user_id',
1648                                           'role_id',
1649                                           'tenant_id'))
1650
1651     @mock.patch('functest.utils.openstack_utils.logger.error')
1652     def test_add_role_user_exception(self, mock_logger_error):
1653         self.assertFalse(openstack_utils.
1654                          add_role_user(Exception,
1655                                        'user_id',
1656                                        'role_id',
1657                                        'tenant_id'))
1658         self.assertTrue(mock_logger_error.called)
1659
1660     def test_delete_tenant_default(self):
1661         with mock.patch('functest.utils.openstack_utils.'
1662                         'is_keystone_v3', return_value=True):
1663             self.assertTrue(openstack_utils.
1664                             delete_tenant(self.keystone_client,
1665                                           'tenant_id'))
1666
1667         with mock.patch('functest.utils.openstack_utils.'
1668                         'is_keystone_v3', return_value=False):
1669             self.assertTrue(openstack_utils.
1670                             delete_tenant(self.keystone_client,
1671                                           'tenant_id'))
1672
1673     @mock.patch('functest.utils.openstack_utils.logger.error')
1674     def test_delete_tenant_exception(self, mock_logger_error):
1675         self.assertFalse(openstack_utils.
1676                          delete_tenant(Exception,
1677                                        'tenant_id'))
1678         self.assertTrue(mock_logger_error.called)
1679
1680     def test_delete_user_default(self):
1681         self.assertTrue(openstack_utils.
1682                         delete_user(self.keystone_client,
1683                                     'user_id'))
1684
1685     @mock.patch('functest.utils.openstack_utils.logger.error')
1686     def test_delete_user_exception(self, mock_logger_error):
1687         self.assertFalse(openstack_utils.
1688                          delete_user(Exception,
1689                                      'user_id'))
1690         self.assertTrue(mock_logger_error.called)
1691
1692     def test_get_resource_default(self):
1693         with mock.patch('functest.utils.openstack_utils.'
1694                         'is_keystone_v3', return_value=True):
1695             self.assertEqual(openstack_utils.
1696                              get_resource(self.heat_client,
1697                                           'stack_id',
1698                                           'resource'),
1699                              self.resource)
1700
1701     @mock.patch('functest.utils.openstack_utils.logger.error')
1702     def test_get_resource_exception(self, mock_logger_error):
1703         self.assertEqual(openstack_utils.
1704                          get_resource(Exception,
1705                                       'stack_id',
1706                                       'resource'),
1707                          None)
1708         self.assertTrue(mock_logger_error.called)
1709
1710     def test_get_or_create_user_for_vnf_get(self):
1711         with mock.patch('functest.utils.openstack_utils.'
1712                         'get_user_id',
1713                         return_value='user_id'), \
1714             mock.patch('functest.utils.openstack_utils.get_tenant_id',
1715                        return_value='tenant_id'):
1716             self.assertFalse(openstack_utils.
1717                              get_or_create_user_for_vnf(self.keystone_client,
1718                                                         'my_vnf'))
1719
1720     def test_get_or_create_user_for_vnf_create(self):
1721         with mock.patch('functest.utils.openstack_utils.'
1722                         'get_user_id',
1723                         return_value=None), \
1724             mock.patch('functest.utils.openstack_utils.get_tenant_id',
1725                        return_value='tenant_id'):
1726             self.assertTrue(openstack_utils.
1727                             get_or_create_user_for_vnf(self.keystone_client,
1728                                                        'my_vnf'))
1729
1730     def test_get_or_create_user_for_vnf_error_get_user_id(self):
1731         with mock.patch('functest.utils.openstack_utils.'
1732                         'get_user_id',
1733                         side_effect=Exception):
1734             self.assertRaises(Exception)
1735
1736     def test_get_or_create_user_for_vnf_error_get_tenant_id(self):
1737         with mock.patch('functest.utils.openstack_utils.'
1738                         'get_user_id',
1739                         return_value='user_id'), \
1740             mock.patch('functest.utils.openstack_utils.get_tenant_id',
1741                        side_effect='Exception'):
1742             self.assertRaises(Exception)
1743
1744     def test_get_or_create_tenant_for_vnf_get(self):
1745         with mock.patch('functest.utils.openstack_utils.'
1746                         'get_tenant_id',
1747                         return_value='tenant_id'):
1748             self.assertFalse(
1749                 openstack_utils.get_or_create_tenant_for_vnf(
1750                     self.keystone_client, 'tenant_name', 'tenant_description'))
1751
1752     def test_get_or_create_tenant_for_vnf_create(self):
1753         with mock.patch('functest.utils.openstack_utils.get_tenant_id',
1754                         return_value=None):
1755             self.assertTrue(
1756                 openstack_utils.get_or_create_tenant_for_vnf(
1757                     self.keystone_client, 'tenant_name', 'tenant_description'))
1758
1759     def test_get_or_create_tenant_for_vnf_error_get_tenant_id(self):
1760         with mock.patch('functest.utils.openstack_utils.'
1761                         'get_tenant_id',
1762                         side_effect=Exception):
1763             self.assertRaises(Exception)
1764
1765     def test_download_and_add_image_on_glance_image_creation_failure(self):
1766         with mock.patch('functest.utils.openstack_utils.'
1767                         'os.makedirs'), \
1768             mock.patch('functest.utils.openstack_utils.'
1769                        'ft_utils.download_url',
1770                        return_value=True), \
1771             mock.patch('functest.utils.openstack_utils.'
1772                        'create_glance_image',
1773                        return_value=''):
1774             resp = openstack_utils.download_and_add_image_on_glance(
1775                 self.glance_client,
1776                 'image_name',
1777                 'http://url',
1778                 'data_dir')
1779             self.assertEqual(resp, False)
1780
1781
1782 if __name__ == "__main__":
1783     logging.disable(logging.CRITICAL)
1784     unittest.main(verbosity=2)