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