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