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     @mock.patch('functest.utils.openstack_utils.get_session')
 422     @mock.patch('functest.utils.openstack_utils.keystoneclient.Client')
 423     @mock.patch('functest.utils.openstack_utils.get_keystone_client_version',
 424                 return_value='3')
 425     @mock.patch('functest.utils.openstack_utils.os.getenv',
 426                 return_value='public')
 427     def test_get_keystone_client_with_interface(self, mock_os_getenv,
 428                                                 mock_keystoneclient_version,
 429                                                 mock_key_client,
 430                                                 mock_get_session):
 431         mock_keystone_obj = mock.Mock()
 432         mock_session_obj = mock.Mock()
 433         mock_key_client.return_value = mock_keystone_obj
 434         mock_get_session.return_value = mock_session_obj
 435         self.assertEqual(openstack_utils.get_keystone_client(),
 436                          mock_keystone_obj)
 437         mock_key_client.assert_called_once_with('3',
 438                                                 session=mock_session_obj,
 439                                                 interface='public')
 440
 441     @mock.patch('functest.utils.openstack_utils.get_session')
 442     @mock.patch('functest.utils.openstack_utils.keystoneclient.Client')
 443     @mock.patch('functest.utils.openstack_utils.get_keystone_client_version',
 444                 return_value='3')
 445     @mock.patch('functest.utils.openstack_utils.os.getenv',
 446                 return_value='admin')
 447     def test_get_keystone_client_no_interface(self, mock_os_getenv,
 448                                               mock_keystoneclient_version,
 449                                               mock_key_client,
 450                                               mock_get_session):
 451         mock_keystone_obj = mock.Mock()
 452         mock_session_obj = mock.Mock()
 453         mock_key_client.return_value = mock_keystone_obj
 454         mock_get_session.return_value = mock_session_obj
 455         self.assertEqual(openstack_utils.get_keystone_client(),
 456                          mock_keystone_obj)
 457         mock_key_client.assert_called_once_with('3',
 458                                                 session=mock_session_obj,
 459                                                 interface='admin')
 460
 461     @mock.patch('functest.utils.openstack_utils.os.getenv',
 462                 return_value=None)
 463     def test_get_nova_client_version_missing_env(self, mock_os_getenv):
 464         self.assertEqual(openstack_utils.get_nova_client_version(),
 465                          openstack_utils.DEFAULT_API_VERSION)
 466
 467     @mock.patch('functest.utils.openstack_utils.logger.info')
 468     @mock.patch('functest.utils.openstack_utils.os.getenv',
 469                 return_value='3')
 470     def test_get_nova_client_version_default(self, mock_os_getenv,
 471                                              mock_logger_info):
 472         self.assertEqual(openstack_utils.get_nova_client_version(),
 473                          '3')
 474         mock_logger_info.assert_called_once_with("OS_COMPUTE_API_VERSION is "
 475                                                  "set in env as '%s'", '3')
 476
 477     def test_get_nova_client(self):
 478         mock_nova_obj = mock.Mock()
 479         mock_session_obj = mock.Mock()
 480         with mock.patch('functest.utils.openstack_utils'
 481                         '.get_nova_client_version', return_value='3'), \
 482             mock.patch('functest.utils.openstack_utils'
 483                        '.novaclient.Client',
 484                        return_value=mock_nova_obj) \
 485             as mock_nova_client, \
 486             mock.patch('functest.utils.openstack_utils.get_session',
 487                        return_value=mock_session_obj):
 488             self.assertEqual(openstack_utils.get_nova_client(),
 489                              mock_nova_obj)
 490             mock_nova_client.assert_called_once_with('3',
 491                                                      session=mock_session_obj)
 492
 493     @mock.patch('functest.utils.openstack_utils.os.getenv',
 494                 return_value=None)
 495     def test_get_cinder_client_version_missing_env(self, mock_os_getenv):
 496         self.assertEqual(openstack_utils.get_cinder_client_version(),
 497                          openstack_utils.DEFAULT_API_VERSION)
 498
 499     @mock.patch('functest.utils.openstack_utils.logger.info')
 500     @mock.patch('functest.utils.openstack_utils.os.getenv',
 501                 return_value='3')
 502     def test_get_cinder_client_version_default(self, mock_os_getenv,
 503                                                mock_logger_info):
 504         self.assertEqual(openstack_utils.get_cinder_client_version(),
 505                          '3')
 506         mock_logger_info.assert_called_once_with("OS_VOLUME_API_VERSION is "
 507                                                  "set in env as '%s'", '3')
 508
 509     def test_get_cinder_client(self):
 510         mock_cinder_obj = mock.Mock()
 511         mock_session_obj = mock.Mock()
 512         with mock.patch('functest.utils.openstack_utils'
 513                         '.get_cinder_client_version', return_value='3'), \
 514             mock.patch('functest.utils.openstack_utils'
 515                        '.cinderclient.Client',
 516                        return_value=mock_cinder_obj) \
 517             as mock_cind_client, \
 518             mock.patch('functest.utils.openstack_utils.get_session',
 519                        return_value=mock_session_obj):
 520             self.assertEqual(openstack_utils.get_cinder_client(),
 521                              mock_cinder_obj)
 522             mock_cind_client.assert_called_once_with('3',
 523                                                      session=mock_session_obj)
 524
 525     @mock.patch('functest.utils.openstack_utils.os.getenv',
 526                 return_value=None)
 527     def test_get_neutron_client_version_missing_env(self, mock_os_getenv):
 528         self.assertEqual(openstack_utils.get_neutron_client_version(),
 529                          openstack_utils.DEFAULT_API_VERSION)
 530
 531     @mock.patch('functest.utils.openstack_utils.logger.info')
 532     @mock.patch('functest.utils.openstack_utils.os.getenv',
 533                 return_value='3')
 534     def test_get_neutron_client_version_default(self, mock_os_getenv,
 535                                                 mock_logger_info):
 536         self.assertEqual(openstack_utils.get_neutron_client_version(),
 537                          '3')
 538         mock_logger_info.assert_called_once_with("OS_NETWORK_API_VERSION is "
 539                                                  "set in env as '%s'", '3')
 540
 541     def test_get_neutron_client(self):
 542         mock_neutron_obj = mock.Mock()
 543         mock_session_obj = mock.Mock()
 544         with mock.patch('functest.utils.openstack_utils'
 545                         '.get_neutron_client_version', return_value='3'), \
 546             mock.patch('functest.utils.openstack_utils'
 547                        '.neutronclient.Client',
 548                        return_value=mock_neutron_obj) \
 549             as mock_neut_client, \
 550             mock.patch('functest.utils.openstack_utils.get_session',
 551                        return_value=mock_session_obj):
 552             self.assertEqual(openstack_utils.get_neutron_client(),
 553                              mock_neutron_obj)
 554             mock_neut_client.assert_called_once_with('3',
 555                                                      session=mock_session_obj)
 556
 557     @mock.patch('functest.utils.openstack_utils.os.getenv',
 558                 return_value=None)
 559     def test_get_glance_client_version_missing_env(self, mock_os_getenv):
 560         self.assertEqual(openstack_utils.get_glance_client_version(),
 561                          openstack_utils.DEFAULT_API_VERSION)
 562
 563     @mock.patch('functest.utils.openstack_utils.logger.info')
 564     @mock.patch('functest.utils.openstack_utils.os.getenv',
 565                 return_value='3')
 566     def test_get_glance_client_version_default(self, mock_os_getenv,
 567                                                mock_logger_info):
 568         self.assertEqual(openstack_utils.get_glance_client_version(),
 569                          '3')
 570         mock_logger_info.assert_called_once_with("OS_IMAGE_API_VERSION is "
 571                                                  "set in env as '%s'", '3')
 572
 573     def test_get_glance_client(self):
 574         mock_glance_obj = mock.Mock()
 575         mock_session_obj = mock.Mock()
 576         with mock.patch('functest.utils.openstack_utils'
 577                         '.get_glance_client_version', return_value='3'), \
 578             mock.patch('functest.utils.openstack_utils'
 579                        '.glanceclient.Client',
 580                        return_value=mock_glance_obj) \
 581             as mock_glan_client, \
 582             mock.patch('functest.utils.openstack_utils.get_session',
 583                        return_value=mock_session_obj):
 584             self.assertEqual(openstack_utils.get_glance_client(),
 585                              mock_glance_obj)
 586             mock_glan_client.assert_called_once_with('3',
 587                                                      session=mock_session_obj)
 588
 589     @mock.patch('functest.utils.openstack_utils.os.getenv',
 590                 return_value=None)
 591     def test_get_heat_client_version_missing_env(self, mock_os_getenv):
 592         self.assertEqual(openstack_utils.get_heat_client_version(),
 593                          openstack_utils.DEFAULT_HEAT_API_VERSION)
 594
 595     @mock.patch('functest.utils.openstack_utils.logger.info')
 596     @mock.patch('functest.utils.openstack_utils.os.getenv', return_value='1')
 597     def test_get_heat_client_version_default(self, mock_os_getenv,
 598                                              mock_logger_info):
 599         self.assertEqual(openstack_utils.get_heat_client_version(), '1')
 600         mock_logger_info.assert_called_once_with(
 601             "OS_ORCHESTRATION_API_VERSION is set in env as '%s'", '1')
 602
 603     def test_get_heat_client(self):
 604         mock_heat_obj = mock.Mock()
 605         mock_session_obj = mock.Mock()
 606         with mock.patch('functest.utils.openstack_utils'
 607                         '.get_heat_client_version', return_value='1'), \
 608             mock.patch('functest.utils.openstack_utils'
 609                        '.heatclient.Client',
 610                        return_value=mock_heat_obj) \
 611             as mock_heat_client, \
 612             mock.patch('functest.utils.openstack_utils.get_session',
 613                        return_value=mock_session_obj):
 614             self.assertEqual(openstack_utils.get_heat_client(),
 615                              mock_heat_obj)
 616             mock_heat_client.assert_called_once_with('1',
 617                                                      session=mock_session_obj)
 618
 619     def test_get_instances_default(self):
 620         self.assertEqual(openstack_utils.get_instances(self.nova_client),
 621                          [self.instance])
 622
 623     @mock.patch('functest.utils.openstack_utils.logger.error')
 624     def test_get_instances_exception(self, mock_logger_error):
 625             self.assertEqual(openstack_utils.
 626                              get_instances(Exception),
 627                              None)
 628             self.assertTrue(mock_logger_error.called)
 629
 630     def test_get_instance_status_default(self):
 631         self.assertEqual(openstack_utils.get_instance_status(self.nova_client,
 632                                                              self.instance),
 633                          'ok')
 634
 635     @mock.patch('functest.utils.openstack_utils.logger.error')
 636     def test_get_instance_status_exception(self, mock_logger_error):
 637             self.assertEqual(openstack_utils.
 638                              get_instance_status(Exception,
 639                                                  self.instance),
 640                              None)
 641             self.assertTrue(mock_logger_error.called)
 642
 643     def test_get_instance_by_name_default(self):
 644         self.assertEqual(openstack_utils.
 645                          get_instance_by_name(self.nova_client,
 646                                               'test_instance'),
 647                          self.instance)
 648
 649     @mock.patch('functest.utils.openstack_utils.logger.error')
 650     def test_get_instance_by_name_exception(self, mock_logger_error):
 651             self.assertEqual(openstack_utils.
 652                              get_instance_by_name(Exception,
 653                                                   'test_instance'),
 654                              None)
 655             self.assertTrue(mock_logger_error.called)
 656
 657     def test_get_flavor_id_default(self):
 658         self.assertEqual(openstack_utils.
 659                          get_flavor_id(self.nova_client,
 660                                        'test_flavor'),
 661                          self.flavor.id)
 662
 663     def test_get_flavor_id_by_ram_range_default(self):
 664         self.assertEqual(openstack_utils.
 665                          get_flavor_id_by_ram_range(self.nova_client,
 666                                                     1, 3),
 667                          self.flavor.id)
 668
 669     def test_get_aggregates_default(self):
 670         self.assertEqual(openstack_utils.
 671                          get_aggregates(self.nova_client),
 672                          [self.aggregate])
 673
 674     @mock.patch('functest.utils.openstack_utils.logger.error')
 675     def test_get_aggregates_exception(self, mock_logger_error):
 676             self.assertEqual(openstack_utils.
 677                              get_aggregates(Exception),
 678                              None)
 679             self.assertTrue(mock_logger_error.called)
 680
 681     def test_get_aggregate_id_default(self):
 682         with mock.patch('functest.utils.openstack_utils.get_aggregates',
 683                         return_value=[self.aggregate]):
 684             self.assertEqual(openstack_utils.
 685                              get_aggregate_id(self.nova_client,
 686                                               'test_aggregate'),
 687                              'aggregate_id')
 688
 689     @mock.patch('functest.utils.openstack_utils.logger.error')
 690     def test_get_aggregate_id_exception(self, mock_logger_error):
 691             self.assertEqual(openstack_utils.
 692                              get_aggregate_id(Exception,
 693                                               'test_aggregate'),
 694                              None)
 695             self.assertTrue(mock_logger_error.called)
 696
 697     def test_get_availability_zone_names_default(self):
 698         with mock.patch('functest.utils.openstack_utils'
 699                         '.get_availability_zones',
 700                         return_value=[self.availability_zone]):
 701             self.assertEqual(openstack_utils.
 702                              get_availability_zone_names(self.nova_client),
 703                              ['test_azone'])
 704
 705     @mock.patch('functest.utils.openstack_utils.logger.error')
 706     def test_get_availability_zone_names_exception(self, mock_logger_error):
 707             self.assertEqual(openstack_utils.
 708                              get_availability_zone_names(Exception),
 709                              None)
 710             self.assertTrue(mock_logger_error.called)
 711
 712     def test_get_availability_zones_default(self):
 713             self.assertEqual(openstack_utils.
 714                              get_availability_zones(self.nova_client),
 715                              [self.availability_zone])
 716
 717     @mock.patch('functest.utils.openstack_utils.logger.error')
 718     def test_get_availability_zones_exception(self, mock_logger_error):
 719             self.assertEqual(openstack_utils.
 720                              get_availability_zones(Exception),
 721                              None)
 722             self.assertTrue(mock_logger_error.called)
 723
 724     def test_get_floating_ips_default(self):
 725             self.assertEqual(openstack_utils.
 726                              get_floating_ips(self.nova_client),
 727                              [self.floating_ip])
 728
 729     @mock.patch('functest.utils.openstack_utils.logger.error')
 730     def test_get_floating_ips_exception(self, mock_logger_error):
 731             self.assertEqual(openstack_utils.
 732                              get_floating_ips(Exception),
 733                              None)
 734             self.assertTrue(mock_logger_error.called)
 735
 736     def test_get_hypervisors_default(self):
 737             self.assertEqual(openstack_utils.
 738                              get_hypervisors(self.nova_client),
 739                              ['test_hostname'])
 740
 741     @mock.patch('functest.utils.openstack_utils.logger.error')
 742     def test_get_hypervisors_exception(self, mock_logger_error):
 743             self.assertEqual(openstack_utils.
 744                              get_hypervisors(Exception),
 745                              None)
 746             self.assertTrue(mock_logger_error.called)
 747
 748     def test_create_aggregate_default(self):
 749             self.assertTrue(openstack_utils.
 750                             create_aggregate(self.nova_client,
 751                                              'test_aggregate',
 752                                              'azone'))
 753
 754     @mock.patch('functest.utils.openstack_utils.logger.error')
 755     def test_create_aggregate_exception(self, mock_logger_error):
 756             self.assertEqual(openstack_utils.
 757                              create_aggregate(Exception,
 758                                               'test_aggregate',
 759                                               'azone'),
 760                              None)
 761             self.assertTrue(mock_logger_error.called)
 762
 763     def test_add_host_to_aggregate_default(self):
 764         with mock.patch('functest.utils.openstack_utils.get_aggregate_id'):
 765                 self.assertTrue(openstack_utils.
 766                                 add_host_to_aggregate(self.nova_client,
 767                                                       'test_aggregate',
 768                                                       'test_hostname'))
 769
 770     @mock.patch('functest.utils.openstack_utils.logger.error')
 771     def test_add_host_to_aggregate_exception(self, mock_logger_error):
 772             self.assertEqual(openstack_utils.
 773                              add_host_to_aggregate(Exception,
 774                                                    'test_aggregate',
 775                                                    'test_hostname'),
 776                              None)
 777             self.assertTrue(mock_logger_error.called)
 778
 779     def test_create_aggregate_with_host_default(self):
 780         with mock.patch('functest.utils.openstack_utils.create_aggregate'), \
 781                 mock.patch('functest.utils.openstack_utils.'
 782                            'add_host_to_aggregate'):
 783             self.assertTrue(openstack_utils.
 784                             create_aggregate_with_host(self.nova_client,
 785                                                        'test_aggregate',
 786                                                        'test_azone',
 787                                                        'test_hostname'))
 788
 789     @mock.patch('functest.utils.openstack_utils.logger.error')
 790     def test_create_aggregate_with_host_exception(self, mock_logger_error):
 791             with mock.patch('functest.utils.openstack_utils.create_aggregate',
 792                             side_effect=Exception):
 793                 self.assertEqual(openstack_utils.
 794                                  create_aggregate_with_host(Exception,
 795                                                             'test_aggregate',
 796                                                             'test_azone',
 797                                                             'test_hostname'),
 798                                  None)
 799                 self.assertTrue(mock_logger_error.called)
 800
 801     def test_create_instance_default(self):
 802         with mock.patch('functest.utils.openstack_utils.'
 803                         'get_nova_client',
 804                         return_value=self.nova_client):
 805             self.assertEqual(openstack_utils.
 806                              create_instance('test_flavor',
 807                                              'image_id',
 808                                              'network_id'),
 809                              self.instance)
 810
 811     @mock.patch('functest.utils.openstack_utils.logger.error')
 812     def test_create_instance_exception(self, mock_logger_error):
 813         with mock.patch('functest.utils.openstack_utils.'
 814                         'get_nova_client',
 815                         return_value=self.nova_client):
 816             self.nova_client.flavors.find.side_effect = Exception
 817             self.assertEqual(openstack_utils.
 818                              create_instance('test_flavor',
 819                                              'image_id',
 820                                              'network_id'),
 821                              None)
 822             self.assertTrue(mock_logger_error)
 823
 824     def test_create_floating_ip_default(self):
 825         with mock.patch('functest.utils.openstack_utils.'
 826                         'get_external_net_id',
 827                         return_value='external_net_id'):
 828             exp_resp = {'fip_addr': 'test_ip', 'fip_id': 'fip_id'}
 829             self.assertEqual(openstack_utils.
 830                              create_floating_ip(self.neutron_client),
 831                              exp_resp)
 832
 833     @mock.patch('functest.utils.openstack_utils.logger.error')
 834     def test_create_floating_ip_exception(self, mock_logger_error):
 835         with mock.patch('functest.utils.openstack_utils.'
 836                         'get_external_net_id',
 837                         return_value='external_net_id'):
 838             self.assertEqual(openstack_utils.
 839                              create_floating_ip(Exception),
 840                              None)
 841             self.assertTrue(mock_logger_error)
 842
 843     def test_add_floating_ip_default(self):
 844         with mock.patch('functest.utils.openstack_utils.get_aggregate_id'):
 845                 self.assertTrue(openstack_utils.
 846                                 add_floating_ip(self.nova_client,
 847                                                 'test_serverid',
 848                                                 'test_floatingip_addr'))
 849
 850     @mock.patch('functest.utils.openstack_utils.logger.error')
 851     def test_add_floating_ip_exception(self, mock_logger_error):
 852             self.assertFalse(openstack_utils.
 853                              add_floating_ip(Exception,
 854                                              'test_serverid',
 855                                              'test_floatingip_addr'))
 856             self.assertTrue(mock_logger_error.called)
 857
 858     def test_delete_instance_default(self):
 859             self.assertTrue(openstack_utils.
 860                             delete_instance(self.nova_client,
 861                                             'instance_id'))
 862
 863     @mock.patch('functest.utils.openstack_utils.logger.error')
 864     def test_delete_instance_exception(self, mock_logger_error):
 865             self.assertFalse(openstack_utils.
 866                              delete_instance(Exception,
 867                                              'instance_id'))
 868             self.assertTrue(mock_logger_error.called)
 869
 870     def test_delete_floating_ip_default(self):
 871             self.assertTrue(openstack_utils.
 872                             delete_floating_ip(self.nova_client,
 873                                                'floating_ip_id'))
 874
 875     @mock.patch('functest.utils.openstack_utils.logger.error')
 876     def test_delete_floating_ip_exception(self, mock_logger_error):
 877             self.assertFalse(openstack_utils.
 878                              delete_floating_ip(Exception,
 879                                                 'floating_ip_id'))
 880             self.assertTrue(mock_logger_error.called)
 881
 882     def test_remove_host_from_aggregate_default(self):
 883         with mock.patch('functest.utils.openstack_utils.'
 884                         'get_aggregate_id'):
 885                 self.assertTrue(openstack_utils.
 886                                 remove_host_from_aggregate(self.nova_client,
 887                                                            'agg_name',
 888                                                            'host_name'))
 889
 890     @mock.patch('functest.utils.openstack_utils.logger.error')
 891     def test_remove_host_from_aggregate_exception(self, mock_logger_error):
 892         with mock.patch('functest.utils.openstack_utils.'
 893                         'get_aggregate_id', side_effect=Exception):
 894             self.assertFalse(openstack_utils.
 895                              remove_host_from_aggregate(self.nova_client,
 896                                                         'agg_name',
 897                                                         'host_name'))
 898             self.assertTrue(mock_logger_error.called)
 899
 900     def test_remove_hosts_from_aggregate_default(self):
 901         with mock.patch('functest.utils.openstack_utils.'
 902                         'get_aggregate_id'), \
 903             mock.patch('functest.utils.openstack_utils.'
 904                        'remove_host_from_aggregate',
 905                        return_value=True) \
 906                 as mock_method:
 907             openstack_utils.remove_hosts_from_aggregate(self.nova_client,
 908                                                         'test_aggregate')
 909             mock_method.assert_any_call(self.nova_client,
 910                                         'test_aggregate',
 911                                         'host_name')
 912
 913     def test_delete_aggregate_default(self):
 914         with mock.patch('functest.utils.openstack_utils.'
 915                         'remove_hosts_from_aggregate'):
 916                 self.assertTrue(openstack_utils.
 917                                 delete_aggregate(self.nova_client,
 918                                                  'agg_name'))
 919
 920     @mock.patch('functest.utils.openstack_utils.logger.error')
 921     def test_delete_aggregate_exception(self, mock_logger_error):
 922         with mock.patch('functest.utils.openstack_utils.'
 923                         'remove_hosts_from_aggregate', side_effect=Exception):
 924             self.assertFalse(openstack_utils.
 925                              delete_aggregate(self.nova_client,
 926                                               'agg_name'))
 927             self.assertTrue(mock_logger_error.called)
 928
 929     def test_get_network_list_default(self):
 930         self.assertEqual(openstack_utils.
 931                          get_network_list(self.neutron_client),
 932                          self.networks)
 933
 934     def test_get_network_list_missing_network(self):
 935         self.assertEqual(openstack_utils.
 936                          get_network_list(self.empty_client),
 937                          None)
 938
 939     def test_get_router_list_default(self):
 940         self.assertEqual(openstack_utils.
 941                          get_router_list(self.neutron_client),
 942                          [self.router])
 943
 944     def test_get_router_list_missing_router(self):
 945         self.assertEqual(openstack_utils.
 946                          get_router_list(self.empty_client),
 947                          None)
 948
 949     def test_get_port_list_default(self):
 950         self.assertEqual(openstack_utils.
 951                          get_port_list(self.neutron_client),
 952                          [self.port])
 953
 954     def test_get_port_list_missing_port(self):
 955         self.assertEqual(openstack_utils.
 956                          get_port_list(self.empty_client),
 957                          None)
 958
 959     def test_get_network_id_default(self):
 960         self.assertEqual(openstack_utils.
 961                          get_network_id(self.neutron_client,
 962                                         'test_network'),
 963                          'network_id')
 964
 965     def test_get_subnet_id_default(self):
 966         self.assertEqual(openstack_utils.
 967                          get_subnet_id(self.neutron_client,
 968                                        'test_subnet'),
 969                          'subnet_id')
 970
 971     def test_get_router_id_default(self):
 972         self.assertEqual(openstack_utils.
 973                          get_router_id(self.neutron_client,
 974                                        'test_router'),
 975                          'router_id')
 976
 977     def test_get_private_net_default(self):
 978         self.assertEqual(openstack_utils.
 979                          get_private_net(self.neutron_client),
 980                          self.networks[0])
 981
 982     def test_get_private_net_missing_net(self):
 983         self.assertEqual(openstack_utils.
 984                          get_private_net(self.empty_client),
 985                          None)
 986
 987     def test_get_external_net_default(self):
 988         self.assertEqual(openstack_utils.
 989                          get_external_net(self.neutron_client),
 990                          'test_network1')
 991
 992     def test_get_external_net_missing_net(self):
 993         self.assertEqual(openstack_utils.
 994                          get_external_net(self.empty_client),
 995                          None)
 996
 997     def test_get_external_net_id_default(self):
 998         self.assertEqual(openstack_utils.
 999                          get_external_net_id(self.neutron_client),
1000                          'network_id1')
1001
1002     def test_get_external_net_id_missing_net(self):
1003         self.assertEqual(openstack_utils.
1004                          get_external_net_id(self.empty_client),
1005                          None)
1006
1007     def test_check_neutron_net_default(self):
1008         self.assertTrue(openstack_utils.
1009                         check_neutron_net(self.neutron_client,
1010                                           'test_network'))
1011
1012     def test_check_neutron_net_missing_net(self):
1013         self.assertFalse(openstack_utils.
1014                          check_neutron_net(self.empty_client,
1015                                            'test_network'))
1016
1017     def test_create_neutron_net_default(self):
1018             self.assertEqual(openstack_utils.
1019                              create_neutron_net(self.neutron_client,
1020                                                 'test_network'),
1021                              'network_id')
1022
1023     @mock.patch('functest.utils.openstack_utils.logger.error')
1024     def test_create_neutron_net_exception(self, mock_logger_error):
1025             self.assertEqual(openstack_utils.
1026                              create_neutron_net(Exception,
1027                                                 'test_network'),
1028                              None)
1029             self.assertTrue(mock_logger_error.called)
1030
1031     def test_create_neutron_subnet_default(self):
1032             self.assertEqual(openstack_utils.
1033                              create_neutron_subnet(self.neutron_client,
1034                                                    'test_subnet',
1035                                                    'test_cidr',
1036                                                    'network_id'),
1037                              'subnet_id')
1038
1039     @mock.patch('functest.utils.openstack_utils.logger.error')
1040     def test_create_neutron_subnet_exception(self, mock_logger_error):
1041             self.assertEqual(openstack_utils.
1042                              create_neutron_subnet(Exception,
1043                                                    'test_subnet',
1044                                                    'test_cidr',
1045                                                    'network_id'),
1046                              None)
1047             self.assertTrue(mock_logger_error.called)
1048
1049     def test_create_neutron_router_default(self):
1050             self.assertEqual(openstack_utils.
1051                              create_neutron_router(self.neutron_client,
1052                                                    'test_router'),
1053                              'router_id')
1054
1055     @mock.patch('functest.utils.openstack_utils.logger.error')
1056     def test_create_neutron_router_exception(self, mock_logger_error):
1057             self.assertEqual(openstack_utils.
1058                              create_neutron_router(Exception,
1059                                                    'test_router'),
1060                              None)
1061             self.assertTrue(mock_logger_error.called)
1062
1063     def test_create_neutron_port_default(self):
1064             self.assertEqual(openstack_utils.
1065                              create_neutron_port(self.neutron_client,
1066                                                  'test_port',
1067                                                  'network_id',
1068                                                  'test_ip'),
1069                              'port_id')
1070
1071     @mock.patch('functest.utils.openstack_utils.logger.error')
1072     def test_create_neutron_port_exception(self, mock_logger_error):
1073             self.assertEqual(openstack_utils.
1074                              create_neutron_port(Exception,
1075                                                  'test_port',
1076                                                  'network_id',
1077                                                  'test_ip'),
1078                              None)
1079             self.assertTrue(mock_logger_error.called)
1080
1081     def test_update_neutron_net_default(self):
1082             self.assertTrue(openstack_utils.
1083                             update_neutron_net(self.neutron_client,
1084                                                'network_id'))
1085
1086     @mock.patch('functest.utils.openstack_utils.logger.error')
1087     def test_update_neutron_net_exception(self, mock_logger_error):
1088             self.assertFalse(openstack_utils.
1089                              update_neutron_net(Exception,
1090                                                 'network_id'))
1091             self.assertTrue(mock_logger_error.called)
1092
1093     def test_update_neutron_port_default(self):
1094             self.assertEqual(openstack_utils.
1095                              update_neutron_port(self.neutron_client,
1096                                                  'port_id',
1097                                                  'test_owner'),
1098                              'port_id')
1099
1100     @mock.patch('functest.utils.openstack_utils.logger.error')
1101     def test_update_neutron_port_exception(self, mock_logger_error):
1102             self.assertEqual(openstack_utils.
1103                              update_neutron_port(Exception,
1104                                                  'port_id',
1105                                                  'test_owner'),
1106                              None)
1107             self.assertTrue(mock_logger_error.called)
1108
1109     def test_add_interface_router_default(self):
1110             self.assertTrue(openstack_utils.
1111                             add_interface_router(self.neutron_client,
1112                                                  'router_id',
1113                                                  'subnet_id'))
1114
1115     @mock.patch('functest.utils.openstack_utils.logger.error')
1116     def test_add_interface_router_exception(self, mock_logger_error):
1117             self.assertFalse(openstack_utils.
1118                              add_interface_router(Exception,
1119                                                   'router_id',
1120                                                   'subnet_id'))
1121             self.assertTrue(mock_logger_error.called)
1122
1123     def test_add_gateway_router_default(self):
1124         with mock.patch('functest.utils.openstack_utils.'
1125                         'get_external_net_id',
1126                         return_value='network_id'):
1127                 self.assertTrue(openstack_utils.
1128                                 add_gateway_router(self.neutron_client,
1129                                                    'router_id'))
1130
1131     @mock.patch('functest.utils.openstack_utils.logger.error')
1132     def test_add_gateway_router_exception(self, mock_logger_error):
1133         with mock.patch('functest.utils.openstack_utils.'
1134                         'get_external_net_id',
1135                         return_value='network_id'):
1136                 self.assertFalse(openstack_utils.
1137                                  add_gateway_router(Exception,
1138                                                     'router_id'))
1139                 self.assertTrue(mock_logger_error.called)
1140
1141     def test_delete_neutron_net_default(self):
1142             self.assertTrue(openstack_utils.
1143                             delete_neutron_net(self.neutron_client,
1144                                                'network_id'))
1145
1146     @mock.patch('functest.utils.openstack_utils.logger.error')
1147     def test_delete_neutron_net_exception(self, mock_logger_error):
1148             self.assertFalse(openstack_utils.
1149                              delete_neutron_net(Exception,
1150                                                 'network_id'))
1151             self.assertTrue(mock_logger_error.called)
1152
1153     def test_delete_neutron_subnet_default(self):
1154             self.assertTrue(openstack_utils.
1155                             delete_neutron_subnet(self.neutron_client,
1156                                                   'subnet_id'))
1157
1158     @mock.patch('functest.utils.openstack_utils.logger.error')
1159     def test_delete_neutron_subnet_exception(self, mock_logger_error):
1160             self.assertFalse(openstack_utils.
1161                              delete_neutron_subnet(Exception,
1162                                                    'subnet_id'))
1163             self.assertTrue(mock_logger_error.called)
1164
1165     def test_delete_neutron_router_default(self):
1166             self.assertTrue(openstack_utils.
1167                             delete_neutron_router(self.neutron_client,
1168                                                   'router_id'))
1169
1170     @mock.patch('functest.utils.openstack_utils.logger.error')
1171     def test_delete_neutron_router_exception(self, mock_logger_error):
1172             self.assertFalse(openstack_utils.
1173                              delete_neutron_router(Exception,
1174                                                    'router_id'))
1175             self.assertTrue(mock_logger_error.called)
1176
1177     def test_delete_neutron_port_default(self):
1178             self.assertTrue(openstack_utils.
1179                             delete_neutron_port(self.neutron_client,
1180                                                 'port_id'))
1181
1182     @mock.patch('functest.utils.openstack_utils.logger.error')
1183     def test_delete_neutron_port_exception(self, mock_logger_error):
1184             self.assertFalse(openstack_utils.
1185                              delete_neutron_port(Exception,
1186                                                  'port_id'))
1187             self.assertTrue(mock_logger_error.called)
1188
1189     def test_remove_interface_router_default(self):
1190             self.assertTrue(openstack_utils.
1191                             remove_interface_router(self.neutron_client,
1192                                                     'router_id',
1193                                                     'subnet_id'))
1194
1195     @mock.patch('functest.utils.openstack_utils.logger.error')
1196     def test_remove_interface_router_exception(self, mock_logger_error):
1197             self.assertFalse(openstack_utils.
1198                              remove_interface_router(Exception,
1199                                                      'router_id',
1200                                                      'subnet_id'))
1201             self.assertTrue(mock_logger_error.called)
1202
1203     def test_remove_gateway_router_default(self):
1204             self.assertTrue(openstack_utils.
1205                             remove_gateway_router(self.neutron_client,
1206                                                   'router_id'))
1207
1208     @mock.patch('functest.utils.openstack_utils.logger.error')
1209     def test_remove_gateway_router_exception(self, mock_logger_error):
1210             self.assertFalse(openstack_utils.
1211                              remove_gateway_router(Exception,
1212                                                    'router_id'))
1213             self.assertTrue(mock_logger_error.called)
1214
1215     def test_create_bgpvpn(self):
1216         self.assertEqual(openstack_utils.
1217                          create_bgpvpn(self.neutron_client),
1218                          self.mock_return)
1219
1220     def test_create_network_association(self):
1221         self.assertEqual(openstack_utils.
1222                          create_network_association(self.neutron_client,
1223                                                     'bgpvpn_id',
1224                                                     'network_id'),
1225                          self.mock_return)
1226
1227     def test_create_router_association(self):
1228         self.assertEqual(openstack_utils.
1229                          create_router_association(self.neutron_client,
1230                                                    'bgpvpn_id',
1231                                                    'router_id'),
1232                          self.mock_return)
1233
1234     def test_update_bgpvpn(self):
1235         self.assertEqual(openstack_utils.
1236                          update_bgpvpn(self.neutron_client,
1237                                        'bgpvpn_id'),
1238                          self.mock_return)
1239
1240     def test_delete_bgpvpn(self):
1241         self.assertEqual(openstack_utils.
1242                          delete_bgpvpn(self.neutron_client,
1243                                        'bgpvpn_id'),
1244                          self.mock_return)
1245
1246     def test_get_bgpvpn(self):
1247         self.assertEqual(openstack_utils.
1248                          get_bgpvpn(self.neutron_client,
1249                                     'bgpvpn_id'),
1250                          self.mock_return)
1251
1252     def test_get_bgpvpn_routers(self):
1253         with mock.patch('functest.utils.openstack_utils.'
1254                         'get_bgpvpn',
1255                         return_value={'bgpvpn':
1256                                       {'routers': [self.router]}}):
1257             self.assertEqual(openstack_utils.
1258                              get_bgpvpn_routers(self.neutron_client,
1259                                                 'bgpvpn_id'),
1260                              [self.router])
1261
1262     def test_get_security_groups_default(self):
1263         self.assertEqual(openstack_utils.
1264                          get_security_groups(self.neutron_client),
1265                          [self.sec_group])
1266
1267     @mock.patch('functest.utils.openstack_utils.logger.error')
1268     def test_get_security_groups_exception(self, mock_logger_error):
1269         self.assertEqual(openstack_utils.
1270                          get_security_groups(Exception),
1271                          None)
1272         self.assertTrue(mock_logger_error.called)
1273
1274     def test_get_security_group_id_default(self):
1275         with mock.patch('functest.utils.openstack_utils.'
1276                         'get_security_groups',
1277                         return_value=[self.sec_group]):
1278             self.assertEqual(openstack_utils.
1279                              get_security_group_id(self.neutron_client,
1280                                                    'test_sec_group'),
1281                              'sec_group_id')
1282
1283     def test_get_security_group_rules_default(self):
1284         self.assertEqual(openstack_utils.
1285                          get_security_group_rules(self.neutron_client,
1286                                                   self.sec_group['id']),
1287                          [self.sec_group_rule])
1288
1289     @mock.patch('functest.utils.openstack_utils.logger.error')
1290     def test_get_security_group_rules_exception(self, mock_logger_error):
1291         self.assertEqual(openstack_utils.
1292                          get_security_group_rules(Exception,
1293                                                   'sec_group_id'),
1294                          None)
1295         self.assertTrue(mock_logger_error.called)
1296
1297     def test_check_security_group_rules_not_exists(self):
1298         self.assertEqual(openstack_utils.
1299                          check_security_group_rules(self.neutron_client,
1300                                                     'sec_group_id_2',
1301                                                     'direction',
1302                                                     'protocol',
1303                                                     'port_min',
1304                                                     'port_max'),
1305                          True)
1306
1307     def test_check_security_group_rules_exists(self):
1308         self.assertEqual(openstack_utils.
1309                          check_security_group_rules(self.neutron_client,
1310                                                     self.sec_group['id'],
1311                                                     'direction',
1312                                                     'protocol',
1313                                                     'port_min',
1314                                                     'port_max'),
1315                          False)
1316
1317     @mock.patch('functest.utils.openstack_utils.logger.error')
1318     def test_check_security_group_rules_exception(self, mock_logger_error):
1319         self.assertEqual(openstack_utils.
1320                          check_security_group_rules(Exception,
1321                                                     'sec_group_id',
1322                                                     'direction',
1323                                                     'protocol',
1324                                                     'port_max',
1325                                                     'port_min'),
1326                          None)
1327         self.assertTrue(mock_logger_error.called)
1328
1329     def test_create_security_group_default(self):
1330         self.assertEqual(openstack_utils.
1331                          create_security_group(self.neutron_client,
1332                                                'test_sec_group',
1333                                                'sec_group_desc'),
1334                          self.sec_group)
1335
1336     @mock.patch('functest.utils.openstack_utils.logger.error')
1337     def test_create_security_group_exception(self, mock_logger_error):
1338         self.assertEqual(openstack_utils.
1339                          create_security_group(Exception,
1340                                                'test_sec_group',
1341                                                'sec_group_desc'),
1342                          None)
1343         self.assertTrue(mock_logger_error.called)
1344
1345     def test_create_secgroup_rule_default(self):
1346         self.assertTrue(openstack_utils.
1347                         create_secgroup_rule(self.neutron_client,
1348                                              'sg_id',
1349                                              'direction',
1350                                              'protocol',
1351                                              80,
1352                                              80))
1353         self.assertTrue(openstack_utils.
1354                         create_secgroup_rule(self.neutron_client,
1355                                              'sg_id',
1356                                              'direction',
1357                                              'protocol'))
1358
1359     @mock.patch('functest.utils.openstack_utils.logger.error')
1360     def test_create_secgroup_rule_invalid_port_range(self, mock_logger_error):
1361         self.assertFalse(openstack_utils.
1362                          create_secgroup_rule(self.neutron_client,
1363                                               'sg_id',
1364                                               'direction',
1365                                               'protocol',
1366                                               80))
1367
1368     @mock.patch('functest.utils.openstack_utils.logger.error')
1369     def test_create_secgroup_rule_exception(self, mock_logger_error):
1370         self.assertFalse(openstack_utils.
1371                          create_secgroup_rule(Exception,
1372                                               'sg_id',
1373                                               'direction',
1374                                               'protocol'))
1375
1376     @mock.patch('functest.utils.openstack_utils.logger.info')
1377     def test_create_security_group_full_default(self, mock_logger_info):
1378         with mock.patch('functest.utils.openstack_utils.'
1379                         'get_security_group_id',
1380                         return_value='sg_id'):
1381             self.assertEqual(openstack_utils.
1382                              create_security_group_full(self.neutron_client,
1383                                                         'sg_name',
1384                                                         'sg_desc'),
1385                              'sg_id')
1386             self.assertTrue(mock_logger_info)
1387
1388     @mock.patch('functest.utils.openstack_utils.logger.info')
1389     @mock.patch('functest.utils.openstack_utils.logger.error')
1390     def test_create_security_group_full_sec_group_fail(self,
1391                                                        mock_logger_error,
1392                                                        mock_logger_info):
1393         with mock.patch('functest.utils.openstack_utils.'
1394                         'get_security_group_id',
1395                         return_value=''), \
1396             mock.patch('functest.utils.openstack_utils.'
1397                        'create_security_group',
1398                        return_value=False):
1399             self.assertEqual(openstack_utils.
1400                              create_security_group_full(self.neutron_client,
1401                                                         'sg_name',
1402                                                         'sg_desc'),
1403                              None)
1404             self.assertTrue(mock_logger_error)
1405             self.assertTrue(mock_logger_info)
1406
1407     @mock.patch('functest.utils.openstack_utils.logger.debug')
1408     @mock.patch('functest.utils.openstack_utils.logger.info')
1409     @mock.patch('functest.utils.openstack_utils.logger.error')
1410     def test_create_security_group_full_secgroup_rule_fail(self,
1411                                                            mock_logger_error,
1412                                                            mock_logger_info,
1413                                                            mock_logger_debug):
1414         with mock.patch('functest.utils.openstack_utils.'
1415                         'get_security_group_id',
1416                         return_value=''), \
1417             mock.patch('functest.utils.openstack_utils.'
1418                        'create_security_group',
1419                        return_value={'id': 'sg_id',
1420                                      'name': 'sg_name'}), \
1421             mock.patch('functest.utils.openstack_utils.'
1422                        'create_secgroup_rule',
1423                        return_value=False):
1424             self.assertEqual(openstack_utils.
1425                              create_security_group_full(self.neutron_client,
1426                                                         'sg_name',
1427                                                         'sg_desc'),
1428                              None)
1429             self.assertTrue(mock_logger_error)
1430             self.assertTrue(mock_logger_info)
1431             self.assertTrue(mock_logger_debug)
1432
1433     def test_add_secgroup_to_instance_default(self):
1434         self.assertTrue(openstack_utils.
1435                         add_secgroup_to_instance(self.nova_client,
1436                                                  'instance_id',
1437                                                  'sec_group_id'))
1438
1439     @mock.patch('functest.utils.openstack_utils.logger.error')
1440     def test_add_secgroup_to_instance_exception(self, mock_logger_error):
1441         self.assertFalse(openstack_utils.
1442                          add_secgroup_to_instance(Exception,
1443                                                   'instance_id',
1444                                                   'sec_group_id'))
1445         self.assertTrue(mock_logger_error.called)
1446
1447     def test_update_sg_quota_default(self):
1448         self.assertTrue(openstack_utils.
1449                         update_sg_quota(self.neutron_client,
1450                                         'tenant_id',
1451                                         'sg_quota',
1452                                         'sg_rule_quota'))
1453
1454     @mock.patch('functest.utils.openstack_utils.logger.error')
1455     def test_update_sg_quota_exception(self, mock_logger_error):
1456         self.assertFalse(openstack_utils.
1457                          update_sg_quota(Exception,
1458                                          'tenant_id',
1459                                          'sg_quota',
1460                                          'sg_rule_quota'))
1461         self.assertTrue(mock_logger_error.called)
1462
1463     def test_delete_security_group_default(self):
1464         self.assertTrue(openstack_utils.
1465                         delete_security_group(self.neutron_client,
1466                                               'sec_group_id'))
1467
1468     @mock.patch('functest.utils.openstack_utils.logger.error')
1469     def test_delete_security_group_exception(self, mock_logger_error):
1470         self.assertFalse(openstack_utils.
1471                          delete_security_group(Exception,
1472                                                'sec_group_id'))
1473         self.assertTrue(mock_logger_error.called)
1474
1475     def test_get_images_default(self):
1476         self.assertEqual(openstack_utils.
1477                          get_images(self.nova_client),
1478                          [self.image])
1479
1480     @mock.patch('functest.utils.openstack_utils.logger.error')
1481     def test_get_images_exception(self, mock_logger_error):
1482         self.assertEqual(openstack_utils.
1483                          get_images(Exception),
1484                          None)
1485         self.assertTrue(mock_logger_error.called)
1486
1487     def test_get_image_id_default(self):
1488         self.assertEqual(openstack_utils.
1489                          get_image_id(self.glance_client,
1490                                       'test_image'),
1491                          'image_id')
1492
1493     # create_glance_image, get_or_create_image
1494     @mock.patch('functest.utils.openstack_utils.logger.error')
1495     def test_create_glance_image_file_present(self, mock_logger_error):
1496         with mock.patch('functest.utils.openstack_utils.'
1497                         'os.path.isfile',
1498                         return_value=False):
1499             self.assertEqual(openstack_utils.
1500                              create_glance_image(self.glance_client,
1501                                                  'test_image',
1502                                                  'file_path'),
1503                              None)
1504             self.assertTrue(mock_logger_error.called)
1505
1506     @mock.patch('functest.utils.openstack_utils.logger.info')
1507     def test_create_glance_image_already_exist(self, mock_logger_info):
1508         with mock.patch('functest.utils.openstack_utils.'
1509                         'os.path.isfile',
1510                         return_value=True), \
1511             mock.patch('functest.utils.openstack_utils.get_image_id',
1512                        return_value='image_id'):
1513                 self.assertEqual(openstack_utils.
1514                                  create_glance_image(self.glance_client,
1515                                                      'test_image',
1516                                                      'file_path'),
1517                                  'image_id')
1518                 self.assertTrue(mock_logger_info.called)
1519
1520     @mock.patch('functest.utils.openstack_utils.logger.info')
1521     def test_create_glance_image_default(self, mock_logger_info):
1522         with mock.patch('functest.utils.openstack_utils.'
1523                         'os.path.isfile',
1524                         return_value=True), \
1525             mock.patch('functest.utils.openstack_utils.get_image_id',
1526                        return_value=''), \
1527             mock.patch('__builtin__.open',
1528                        mock.mock_open(read_data='1')) as m:
1529                 self.assertEqual(openstack_utils.
1530                                  create_glance_image(self.glance_client,
1531                                                      'test_image',
1532                                                      'file_path'),
1533                                  'image_id')
1534                 m.assert_called_once_with('file_path')
1535                 self.assertTrue(mock_logger_info.called)
1536
1537     @mock.patch('functest.utils.openstack_utils.logger.error')
1538     def test_create_glance_image_exception(self, mock_logger_error):
1539         with mock.patch('functest.utils.openstack_utils.'
1540                         'os.path.isfile',
1541                         return_value=True), \
1542             mock.patch('functest.utils.openstack_utils.get_image_id',
1543                        side_effect=Exception):
1544                 self.assertEqual(openstack_utils.
1545                                  create_glance_image(self.glance_client,
1546                                                      'test_image',
1547                                                      'file_path'),
1548                                  None)
1549                 self.assertTrue(mock_logger_error.called)
1550
1551     def test_delete_glance_image_default(self):
1552         self.assertTrue(openstack_utils.
1553                         delete_glance_image(self.nova_client,
1554                                             'image_id'))
1555
1556     @mock.patch('functest.utils.openstack_utils.logger.error')
1557     def test_delete_glance_image_exception(self, mock_logger_error):
1558         self.assertFalse(openstack_utils.
1559                          delete_glance_image(Exception,
1560                                              'image_id'))
1561         self.assertTrue(mock_logger_error.called)
1562
1563     def test_get_volumes_default(self):
1564         self.assertEqual(openstack_utils.
1565                          get_volumes(self.cinder_client),
1566                          [self.volume])
1567
1568     @mock.patch('functest.utils.openstack_utils.logger.error')
1569     def test_get_volumes_exception(self, mock_logger_error):
1570         self.assertEqual(openstack_utils.
1571                          get_volumes(Exception),
1572                          None)
1573         self.assertTrue(mock_logger_error.called)
1574
1575     def test_list_volume_types_default_private(self):
1576         self.assertEqual(openstack_utils.
1577                          list_volume_types(self.cinder_client,
1578                                            public=False,
1579                                            private=True),
1580                          [self.volume_types[1]])
1581
1582     def test_list_volume_types_default_public(self):
1583         self.assertEqual(openstack_utils.
1584                          list_volume_types(self.cinder_client,
1585                                            public=True,
1586                                            private=False),
1587                          [self.volume_types[0]])
1588
1589     @mock.patch('functest.utils.openstack_utils.logger.error')
1590     def test_list_volume_types_exception(self, mock_logger_error):
1591         self.assertEqual(openstack_utils.
1592                          list_volume_types(Exception),
1593                          None)
1594         self.assertTrue(mock_logger_error.called)
1595
1596     def test_create_volume_type_default(self):
1597         self.assertEqual(openstack_utils.
1598                          create_volume_type(self.cinder_client,
1599                                             'test_volume_type'),
1600                          self.volume_types[0])
1601
1602     @mock.patch('functest.utils.openstack_utils.logger.error')
1603     def test_create_volume_type_exception(self, mock_logger_error):
1604         self.assertEqual(openstack_utils.
1605                          create_volume_type(Exception,
1606                                             'test_volume_type'),
1607                          None)
1608         self.assertTrue(mock_logger_error.called)
1609
1610     def test_update_cinder_quota_default(self):
1611         self.assertTrue(openstack_utils.
1612                         update_cinder_quota(self.cinder_client,
1613                                             'tenant_id',
1614                                             'vols_quota',
1615                                             'snap_quota',
1616                                             'giga_quota'))
1617
1618     @mock.patch('functest.utils.openstack_utils.logger.error')
1619     def test_update_cinder_quota_exception(self, mock_logger_error):
1620         self.assertFalse(openstack_utils.
1621                          update_cinder_quota(Exception,
1622                                              'tenant_id',
1623                                              'vols_quota',
1624                                              'snap_quota',
1625                                              'giga_quota'))
1626         self.assertTrue(mock_logger_error.called)
1627
1628     def test_delete_volume_default(self):
1629         self.assertTrue(openstack_utils.
1630                         delete_volume(self.cinder_client,
1631                                       'volume_id',
1632                                       forced=False))
1633
1634         self.assertTrue(openstack_utils.
1635                         delete_volume(self.cinder_client,
1636                                       'volume_id',
1637                                       forced=True))
1638
1639     @mock.patch('functest.utils.openstack_utils.logger.error')
1640     def test_delete_volume_exception(self, mock_logger_error):
1641         self.assertFalse(openstack_utils.
1642                          delete_volume(Exception,
1643                                        'volume_id',
1644                                        forced=True))
1645         self.assertTrue(mock_logger_error.called)
1646
1647     def test_delete_volume_type_default(self):
1648         self.assertTrue(openstack_utils.
1649                         delete_volume_type(self.cinder_client,
1650                                            self.volume_types[0]))
1651
1652     @mock.patch('functest.utils.openstack_utils.logger.error')
1653     def test_delete_volume_type_exception(self, mock_logger_error):
1654         self.assertFalse(openstack_utils.
1655                          delete_volume_type(Exception,
1656                                             self.volume_types[0]))
1657         self.assertTrue(mock_logger_error.called)
1658
1659     def test_get_tenants_default(self):
1660         with mock.patch('functest.utils.openstack_utils.'
1661                         'is_keystone_v3', return_value=True):
1662             self.assertEqual(openstack_utils.
1663                              get_tenants(self.keystone_client),
1664                              [self.tenant])
1665         with mock.patch('functest.utils.openstack_utils.'
1666                         'is_keystone_v3', return_value=False):
1667             self.assertEqual(openstack_utils.
1668                              get_tenants(self.keystone_client),
1669                              [self.tenant])
1670
1671     @mock.patch('functest.utils.openstack_utils.logger.error')
1672     def test_get_tenants_exception(self, mock_logger_error):
1673         self.assertEqual(openstack_utils.
1674                          get_tenants(Exception),
1675                          None)
1676         self.assertTrue(mock_logger_error.called)
1677
1678     def test_get_users_default(self):
1679         self.assertEqual(openstack_utils.
1680                          get_users(self.keystone_client),
1681                          [self.user])
1682
1683     @mock.patch('functest.utils.openstack_utils.logger.error')
1684     def test_get_users_exception(self, mock_logger_error):
1685         self.assertEqual(openstack_utils.
1686                          get_users(Exception),
1687                          None)
1688         self.assertTrue(mock_logger_error.called)
1689
1690     def test_get_tenant_id_default(self):
1691         self.assertEqual(openstack_utils.
1692                          get_tenant_id(self.keystone_client,
1693                                        'test_tenant'),
1694                          'tenant_id')
1695
1696     def test_get_user_id_default(self):
1697         self.assertEqual(openstack_utils.
1698                          get_user_id(self.keystone_client,
1699                                      'test_user'),
1700                          'user_id')
1701
1702     def test_get_role_id_default(self):
1703         self.assertEqual(openstack_utils.
1704                          get_role_id(self.keystone_client,
1705                                      'test_role'),
1706                          'role_id')
1707
1708     def test_create_tenant_default(self):
1709         with mock.patch('functest.utils.openstack_utils.'
1710                         'is_keystone_v3', return_value=True):
1711             self.assertEqual(openstack_utils.
1712                              create_tenant(self.keystone_client,
1713                                            'test_tenant',
1714                                            'tenant_desc'),
1715                              'tenant_id')
1716         with mock.patch('functest.utils.openstack_utils.'
1717                         'is_keystone_v3', return_value=False):
1718             self.assertEqual(openstack_utils.
1719                              create_tenant(self.keystone_client,
1720                                            'test_tenant',
1721                                            'tenant_desc'),
1722                              'tenant_id')
1723
1724     @mock.patch('functest.utils.openstack_utils.logger.error')
1725     def test_create_tenant_exception(self, mock_logger_error):
1726         self.assertEqual(openstack_utils.
1727                          create_tenant(Exception,
1728                                        'test_tenant',
1729                                        'tenant_desc'),
1730                          None)
1731         self.assertTrue(mock_logger_error.called)
1732
1733     def test_create_user_default(self):
1734         with mock.patch('functest.utils.openstack_utils.'
1735                         'is_keystone_v3', return_value=True):
1736             self.assertEqual(openstack_utils.
1737                              create_user(self.keystone_client,
1738                                          'test_user',
1739                                          'password',
1740                                          'email',
1741                                          'tenant_id'),
1742                              'user_id')
1743         with mock.patch('functest.utils.openstack_utils.'
1744                         'is_keystone_v3', return_value=False):
1745             self.assertEqual(openstack_utils.
1746                              create_user(self.keystone_client,
1747                                          'test_user',
1748                                          'password',
1749                                          'email',
1750                                          'tenant_id'),
1751                              'user_id')
1752
1753     @mock.patch('functest.utils.openstack_utils.logger.error')
1754     def test_create_user_exception(self, mock_logger_error):
1755         self.assertEqual(openstack_utils.
1756                          create_user(Exception,
1757                                      'test_user',
1758                                      'password',
1759                                      'email',
1760                                      'tenant_id'),
1761                          None)
1762         self.assertTrue(mock_logger_error.called)
1763
1764     def test_add_role_user_default(self):
1765         with mock.patch('functest.utils.openstack_utils.'
1766                         'is_keystone_v3', return_value=True):
1767             self.assertTrue(openstack_utils.
1768                             add_role_user(self.keystone_client,
1769                                           'user_id',
1770                                           'role_id',
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                             add_role_user(self.keystone_client,
1777                                           'user_id',
1778                                           'role_id',
1779                                           'tenant_id'))
1780
1781     @mock.patch('functest.utils.openstack_utils.logger.error')
1782     def test_add_role_user_exception(self, mock_logger_error):
1783         self.assertFalse(openstack_utils.
1784                          add_role_user(Exception,
1785                                        'user_id',
1786                                        'role_id',
1787                                        'tenant_id'))
1788         self.assertTrue(mock_logger_error.called)
1789
1790     def test_delete_tenant_default(self):
1791         with mock.patch('functest.utils.openstack_utils.'
1792                         'is_keystone_v3', return_value=True):
1793             self.assertTrue(openstack_utils.
1794                             delete_tenant(self.keystone_client,
1795                                           'tenant_id'))
1796
1797         with mock.patch('functest.utils.openstack_utils.'
1798                         'is_keystone_v3', return_value=False):
1799             self.assertTrue(openstack_utils.
1800                             delete_tenant(self.keystone_client,
1801                                           'tenant_id'))
1802
1803     @mock.patch('functest.utils.openstack_utils.logger.error')
1804     def test_delete_tenant_exception(self, mock_logger_error):
1805         self.assertFalse(openstack_utils.
1806                          delete_tenant(Exception,
1807                                        'tenant_id'))
1808         self.assertTrue(mock_logger_error.called)
1809
1810     def test_delete_user_default(self):
1811         self.assertTrue(openstack_utils.
1812                         delete_user(self.keystone_client,
1813                                     'user_id'))
1814
1815     @mock.patch('functest.utils.openstack_utils.logger.error')
1816     def test_delete_user_exception(self, mock_logger_error):
1817         self.assertFalse(openstack_utils.
1818                          delete_user(Exception,
1819                                      'user_id'))
1820         self.assertTrue(mock_logger_error.called)
1821
1822     def test_get_resource_default(self):
1823         with mock.patch('functest.utils.openstack_utils.'
1824                         'is_keystone_v3', return_value=True):
1825             self.assertEqual(openstack_utils.
1826                              get_resource(self.heat_client,
1827                                           'stack_id',
1828                                           'resource'),
1829                              self.resource)
1830
1831     @mock.patch('functest.utils.openstack_utils.logger.error')
1832     def test_get_resource_exception(self, mock_logger_error):
1833         self.assertEqual(openstack_utils.
1834                          get_resource(Exception,
1835                                       'stack_id',
1836                                       'resource'),
1837                          None)
1838         self.assertTrue(mock_logger_error.called)
1839
1840
1841 if __name__ == "__main__":
1842     unittest.main(verbosity=2)