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 from functest.utils.constants import CONST
  17
  18
  19 class OSUtilsTesting(unittest.TestCase):
  20
  21     def _get_env_cred_dict(self, os_prefix=''):
  22         return {'OS_USERNAME': os_prefix + 'username',
  23                 'OS_PASSWORD': os_prefix + 'password',
  24                 'OS_AUTH_URL': os_prefix + 'auth_url',
  25                 'OS_TENANT_NAME': os_prefix + 'tenant_name',
  26                 'OS_USER_DOMAIN_NAME': os_prefix + 'user_domain_name',
  27                 'OS_PROJECT_DOMAIN_NAME': os_prefix + 'project_domain_name',
  28                 'OS_PROJECT_NAME': os_prefix + 'project_name',
  29                 'OS_ENDPOINT_TYPE': os_prefix + 'endpoint_type',
  30                 'OS_REGION_NAME': os_prefix + 'region_name',
  31                 'OS_CACERT': os_prefix + 'https_cacert',
  32                 'OS_INSECURE': os_prefix + 'https_insecure'}
  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                 'https_insecure': 'test_https_insecure'}
  44
  45     def setUp(self):
  46         self.env_vars = ['OS_AUTH_URL', 'OS_USERNAME', 'OS_PASSWORD']
  47         self.tenant_name = 'test_tenant_name'
  48         self.env_cred_dict = self._get_env_cred_dict()
  49         self.os_environs = self._get_env_cred_dict(os_prefix='test_')
  50         self.os_env_vars = self._get_os_env_vars()
  51
  52         mock_obj = mock.Mock()
  53         attrs = {'name': 'test_flavor',
  54                  'id': 'flavor_id',
  55                  'ram': 2}
  56         mock_obj.configure_mock(**attrs)
  57         self.flavor = mock_obj
  58
  59         mock_obj = mock.Mock()
  60         attrs = {'name': 'test_aggregate',
  61                  'id': 'aggregate_id',
  62                  'hosts': ['host_name']}
  63         mock_obj.configure_mock(**attrs)
  64         self.aggregate = mock_obj
  65
  66         mock_obj = mock.Mock()
  67         attrs = {'id': 'instance_id',
  68                  'name': 'test_instance',
  69                  'status': 'ok'}
  70         mock_obj.configure_mock(**attrs)
  71         self.instance = mock_obj
  72
  73         mock_obj = mock.Mock()
  74         attrs = {'id': 'azone_id',
  75                  'zoneName': 'test_azone',
  76                  'status': 'ok'}
  77         mock_obj.configure_mock(**attrs)
  78         self.availability_zone = mock_obj
  79
  80         mock_obj = mock.Mock()
  81         attrs = {'floating_network_id': 'floating_id',
  82                  'floating_ip_address': 'test_floating_ip'}
  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                  'hypervisors.list.return_value': [self.hypervisor],
 119                  'create.return_value': mock.Mock(),
 120                  'add_security_group.return_value': mock.Mock(),
 121                  'images.list.return_value': [self.image],
 122                  'images.delete.return_value': mock.Mock(),
 123                  }
 124         self.nova_client.configure_mock(**attrs)
 125
 126         self.glance_client = mock.Mock()
 127         attrs = {'images.list.return_value': [self.image],
 128                  'images.create.return_value': self.image,
 129                  'images.upload.return_value': mock.Mock()}
 130         self.glance_client.configure_mock(**attrs)
 131
 132         mock_obj = mock.Mock()
 133         attrs = {'id': 'volume_id',
 134                  'name': 'test_volume'}
 135         mock_obj.configure_mock(**attrs)
 136         self.volume = mock_obj
 137
 138         mock_obj = mock.Mock()
 139         attrs = {'id': 'volume_type_id',
 140                  'name': 'test_volume_type',
 141                  'is_public': True}
 142         mock_obj.configure_mock(**attrs)
 143         self.volume_types = [mock_obj]
 144
 145         mock_obj = mock.Mock()
 146         attrs = {'id': 'volume_type_id',
 147                  'name': 'test_volume_type',
 148                  'is_public': False}
 149         mock_obj.configure_mock(**attrs)
 150         self.volume_types.append(mock_obj)
 151
 152         self.cinder_client = mock.Mock()
 153         attrs = {'volumes.list.return_value': [self.volume],
 154                  'volume_types.list.return_value': self.volume_types,
 155                  'volume_types.create.return_value': self.volume_types[0],
 156                  'volume_types.delete.return_value': mock.Mock(),
 157                  'quotas.update.return_value': mock.Mock(),
 158                  'volumes.detach.return_value': mock.Mock(),
 159                  'volumes.force_delete.return_value': mock.Mock(),
 160                  'volumes.delete.return_value': mock.Mock()
 161                  }
 162         self.cinder_client.configure_mock(**attrs)
 163
 164         self.resource = mock.Mock()
 165         attrs = {'id': 'resource_test_id',
 166                  'name': 'resource_test_name'
 167                  }
 168
 169         self.heat_client = mock.Mock()
 170         attrs = {'resources.get.return_value': self.resource}
 171         self.heat_client.configure_mock(**attrs)
 172
 173         mock_obj = mock.Mock()
 174         attrs = {'id': 'tenant_id',
 175                  'name': 'test_tenant'}
 176         mock_obj.configure_mock(**attrs)
 177         self.tenant = mock_obj
 178
 179         mock_obj = mock.Mock()
 180         attrs = {'id': 'user_id',
 181                  'name': 'test_user'}
 182         mock_obj.configure_mock(**attrs)
 183         self.user = mock_obj
 184
 185         mock_obj = mock.Mock()
 186         attrs = {'id': 'role_id',
 187                  'name': 'test_role'}
 188         mock_obj.configure_mock(**attrs)
 189         self.role = mock_obj
 190
 191         mock_obj = mock.Mock()
 192         attrs = {'id': 'domain_id',
 193                  'name': 'test_domain'}
 194         mock_obj.configure_mock(**attrs)
 195         self.domain = mock_obj
 196
 197         self.keystone_client = mock.Mock()
 198         attrs = {'projects.list.return_value': [self.tenant],
 199                  'tenants.list.return_value': [self.tenant],
 200                  'users.list.return_value': [self.user],
 201                  'roles.list.return_value': [self.role],
 202                  'domains.list.return_value': [self.domain],
 203                  'projects.create.return_value': self.tenant,
 204                  'tenants.create.return_value': self.tenant,
 205                  'users.create.return_value': self.user,
 206                  'roles.grant.return_value': mock.Mock(),
 207                  'roles.add_user_role.return_value': mock.Mock(),
 208                  'projects.delete.return_value': mock.Mock(),
 209                  'tenants.delete.return_value': mock.Mock(),
 210                  'users.delete.return_value': mock.Mock(),
 211                  }
 212         self.keystone_client.configure_mock(**attrs)
 213
 214         self.router = {'id': 'router_id',
 215                        'name': 'test_router'}
 216
 217         self.subnet = {'id': 'subnet_id',
 218                        'name': 'test_subnet'}
 219
 220         self.networks = [{'id': 'network_id',
 221                           'name': 'test_network',
 222                           'router:external': False,
 223                           'shared': True,
 224                           'subnets': [self.subnet]},
 225                          {'id': 'network_id1',
 226                           'name': 'test_network1',
 227                           'router:external': True,
 228                           'shared': True,
 229                           'subnets': [self.subnet]}]
 230
 231         self.port = {'id': 'port_id',
 232                      'name': 'test_port'}
 233
 234         self.sec_group = {'id': 'sec_group_id',
 235                           'name': 'test_sec_group'}
 236
 237         self.sec_group_rule = {'id': 'sec_group_rule_id',
 238                                'direction': 'direction',
 239                                'protocol': 'protocol',
 240                                'port_range_max': 'port_max',
 241                                'security_group_id': self.sec_group['id'],
 242                                'port_range_min': 'port_min'}
 243         self.neutron_floatingip = {'id': 'fip_id',
 244                                    'floating_ip_address': 'test_ip'}
 245         self.neutron_client = mock.Mock()
 246         attrs = {'list_networks.return_value': {'networks': self.networks},
 247                  'list_routers.return_value': {'routers': [self.router]},
 248                  'list_ports.return_value': {'ports': [self.port]},
 249                  'list_subnets.return_value': {'subnets': [self.subnet]},
 250                  'create_network.return_value': {'network': self.networks[0]},
 251                  'create_subnet.return_value': {'subnets': [self.subnet]},
 252                  'create_router.return_value': {'router': self.router},
 253                  'create_port.return_value': {'port': self.port},
 254                  'create_floatingip.return_value': {'floatingip':
 255                                                     self.neutron_floatingip},
 256                  'update_network.return_value': mock.Mock(),
 257                  'update_port.return_value': {'port': self.port},
 258                  'add_interface_router.return_value': mock.Mock(),
 259                  'add_gateway_router.return_value': mock.Mock(),
 260                  'delete_network.return_value': mock.Mock(),
 261                  'delete_subnet.return_value': mock.Mock(),
 262                  'delete_router.return_value': mock.Mock(),
 263                  'delete_port.return_value': mock.Mock(),
 264                  'remove_interface_router.return_value': mock.Mock(),
 265                  'remove_gateway_router.return_value': mock.Mock(),
 266                  'list_security_groups.return_value': {'security_groups':
 267                                                        [self.sec_group]},
 268                  'list_security_group_rules.'
 269                  'return_value': {'security_group_rules':
 270                                   [self.sec_group_rule]},
 271                  'create_security_group_rule.return_value': mock.Mock(),
 272                  'create_security_group.return_value': {'security_group':
 273                                                         self.sec_group},
 274                  'update_quota.return_value': mock.Mock(),
 275                  'delete_security_group.return_value': mock.Mock(),
 276                  'list_floatingips.return_value': {'floatingips':
 277                                                    [self.floating_ip]},
 278                  'delete_floatingip.return_value': mock.Mock(),
 279                  }
 280         self.neutron_client.configure_mock(**attrs)
 281
 282         self.empty_client = mock.Mock()
 283         attrs = {'list_networks.return_value': {'networks': []},
 284                  'list_routers.return_value': {'routers': []},
 285                  'list_ports.return_value': {'ports': []},
 286                  'list_subnets.return_value': {'subnets': []}}
 287         self.empty_client.configure_mock(**attrs)
 288
 289     @mock.patch('functest.utils.openstack_utils.os.getenv',
 290                 return_value=None)
 291     def test_is_keystone_v3_missing_identity(self, mock_os_getenv):
 292         self.assertEqual(openstack_utils.is_keystone_v3(), False)
 293
 294     @mock.patch('functest.utils.openstack_utils.os.getenv',
 295                 return_value='3')
 296     def test_is_keystone_v3_default(self, mock_os_getenv):
 297         self.assertEqual(openstack_utils.is_keystone_v3(), True)
 298
 299     @mock.patch('functest.utils.openstack_utils.is_keystone_v3',
 300                 return_value=False)
 301     def test_get_rc_env_vars_missing_identity(self, mock_get_rc_env):
 302         exp_resp = self.env_vars
 303         exp_resp.extend(['OS_TENANT_NAME'])
 304         self.assertEqual(openstack_utils.get_rc_env_vars(), exp_resp)
 305
 306     @mock.patch('functest.utils.openstack_utils.is_keystone_v3',
 307                 return_value=True)
 308     def test_get_rc_env_vars_default(self, mock_get_rc_env):
 309         exp_resp = self.env_vars
 310         exp_resp.extend(['OS_PROJECT_NAME',
 311                          'OS_USER_DOMAIN_NAME',
 312                          'OS_PROJECT_DOMAIN_NAME'])
 313         self.assertEqual(openstack_utils.get_rc_env_vars(), exp_resp)
 314
 315     @mock.patch('functest.utils.openstack_utils.get_rc_env_vars')
 316     def test_check_credentials_missing_env(self, mock_get_rc_env):
 317         exp_resp = self.env_vars
 318         exp_resp.extend(['OS_TENANT_NAME'])
 319         mock_get_rc_env.return_value = exp_resp
 320         with mock.patch.dict('functest.utils.openstack_utils.os.environ', {},
 321                              clear=True):
 322             self.assertEqual(openstack_utils.check_credentials(), False)
 323
 324     @mock.patch('functest.utils.openstack_utils.get_rc_env_vars')
 325     def test_check_credentials_default(self, mock_get_rc_env):
 326         exp_resp = ['OS_TENANT_NAME']
 327         mock_get_rc_env.return_value = exp_resp
 328         with mock.patch.dict('functest.utils.openstack_utils.os.environ',
 329                              {'OS_TENANT_NAME': self.tenant_name},
 330                              clear=True):
 331             self.assertEqual(openstack_utils.check_credentials(), True)
 332
 333     def test_get_env_cred_dict(self):
 334         self.assertDictEqual(openstack_utils.get_env_cred_dict(),
 335                              self.env_cred_dict)
 336
 337     @mock.patch('functest.utils.openstack_utils.get_rc_env_vars')
 338     def test_get_credentials_default(self, mock_get_rc_env):
 339         mock_get_rc_env.return_value = self.env_cred_dict.keys()
 340         with mock.patch.dict('functest.utils.openstack_utils.os.environ',
 341                              self.os_environs,
 342                              clear=True):
 343             self.assertDictEqual(openstack_utils.get_credentials(),
 344                                  self.os_env_vars)
 345
 346     def _get_credentials_missing_env(self, var):
 347         dic = copy.deepcopy(self.os_environs)
 348         dic.pop(var)
 349         with mock.patch('functest.utils.openstack_utils.get_rc_env_vars',
 350                         return_value=self.env_cred_dict.keys()), \
 351                 mock.patch.dict('functest.utils.openstack_utils.os.environ',
 352                                 dic,
 353                                 clear=True):
 354             self.assertRaises(openstack_utils.MissingEnvVar,
 355                               lambda: openstack_utils.get_credentials())
 356
 357     def test_get_credentials_missing_username(self):
 358         self._get_credentials_missing_env('OS_USERNAME')
 359
 360     def test_get_credentials_missing_password(self):
 361         self._get_credentials_missing_env('OS_PASSWORD')
 362
 363     def test_get_credentials_missing_auth_url(self):
 364         self._get_credentials_missing_env('OS_AUTH_URL')
 365
 366     def test_get_credentials_missing_tenantname(self):
 367         self._get_credentials_missing_env('OS_TENANT_NAME')
 368
 369     def test_get_credentials_missing_domainname(self):
 370         self._get_credentials_missing_env('OS_USER_DOMAIN_NAME')
 371
 372     def test_get_credentials_missing_projectname(self):
 373         self._get_credentials_missing_env('OS_PROJECT_NAME')
 374
 375     def test_get_credentials_missing_endpoint_type(self):
 376         self._get_credentials_missing_env('OS_ENDPOINT_TYPE')
 377
 378     def _test_source_credentials(self, msg, key='OS_TENANT_NAME',
 379                                  value='admin'):
 380         try:
 381             del os.environ[key]
 382         except:
 383             pass
 384         f = 'rc_file'
 385         with mock.patch('__builtin__.open', mock.mock_open(read_data=msg),
 386                         create=True) as m:
 387             m.return_value.__iter__ = lambda self: iter(self.readline, '')
 388             openstack_utils.source_credentials(f)
 389             m.assert_called_once_with(f, 'r')
 390             self.assertEqual(os.environ[key], value)
 391
 392     def test_source_credentials(self):
 393         self._test_source_credentials('OS_TENANT_NAME=admin')
 394         self._test_source_credentials('OS_TENANT_NAME= admin')
 395         self._test_source_credentials('OS_TENANT_NAME = admin')
 396         self._test_source_credentials('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('export OS_TENANT_NAME = admin')
 400         self._test_source_credentials('export OS_TENANT_NAME = "admin"')
 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.neutron_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.neutron_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_get_security_groups_default(self):
1216         self.assertEqual(openstack_utils.
1217                          get_security_groups(self.neutron_client),
1218                          [self.sec_group])
1219
1220     @mock.patch('functest.utils.openstack_utils.logger.error')
1221     def test_get_security_groups_exception(self, mock_logger_error):
1222         self.assertEqual(openstack_utils.
1223                          get_security_groups(Exception),
1224                          None)
1225         self.assertTrue(mock_logger_error.called)
1226
1227     def test_get_security_group_id_default(self):
1228         with mock.patch('functest.utils.openstack_utils.'
1229                         'get_security_groups',
1230                         return_value=[self.sec_group]):
1231             self.assertEqual(openstack_utils.
1232                              get_security_group_id(self.neutron_client,
1233                                                    'test_sec_group'),
1234                              'sec_group_id')
1235
1236     def test_get_security_group_rules_default(self):
1237         self.assertEqual(openstack_utils.
1238                          get_security_group_rules(self.neutron_client,
1239                                                   self.sec_group['id']),
1240                          [self.sec_group_rule])
1241
1242     @mock.patch('functest.utils.openstack_utils.logger.error')
1243     def test_get_security_group_rules_exception(self, mock_logger_error):
1244         self.assertEqual(openstack_utils.
1245                          get_security_group_rules(Exception,
1246                                                   'sec_group_id'),
1247                          None)
1248         self.assertTrue(mock_logger_error.called)
1249
1250     def test_check_security_group_rules_not_exists(self):
1251         self.assertEqual(openstack_utils.
1252                          check_security_group_rules(self.neutron_client,
1253                                                     'sec_group_id_2',
1254                                                     'direction',
1255                                                     'protocol',
1256                                                     'port_min',
1257                                                     'port_max'),
1258                          True)
1259
1260     def test_check_security_group_rules_exists(self):
1261         self.assertEqual(openstack_utils.
1262                          check_security_group_rules(self.neutron_client,
1263                                                     self.sec_group['id'],
1264                                                     'direction',
1265                                                     'protocol',
1266                                                     'port_min',
1267                                                     'port_max'),
1268                          False)
1269
1270     @mock.patch('functest.utils.openstack_utils.logger.error')
1271     def test_check_security_group_rules_exception(self, mock_logger_error):
1272         self.assertEqual(openstack_utils.
1273                          check_security_group_rules(Exception,
1274                                                     'sec_group_id',
1275                                                     'direction',
1276                                                     'protocol',
1277                                                     'port_max',
1278                                                     'port_min'),
1279                          None)
1280         self.assertTrue(mock_logger_error.called)
1281
1282     def test_create_security_group_default(self):
1283         self.assertEqual(openstack_utils.
1284                          create_security_group(self.neutron_client,
1285                                                'test_sec_group',
1286                                                'sec_group_desc'),
1287                          self.sec_group)
1288
1289     @mock.patch('functest.utils.openstack_utils.logger.error')
1290     def test_create_security_group_exception(self, mock_logger_error):
1291         self.assertEqual(openstack_utils.
1292                          create_security_group(Exception,
1293                                                'test_sec_group',
1294                                                'sec_group_desc'),
1295                          None)
1296         self.assertTrue(mock_logger_error.called)
1297
1298     def test_create_secgroup_rule_default(self):
1299         self.assertTrue(openstack_utils.
1300                         create_secgroup_rule(self.neutron_client,
1301                                              'sg_id',
1302                                              'direction',
1303                                              'protocol',
1304                                              80,
1305                                              80))
1306         self.assertTrue(openstack_utils.
1307                         create_secgroup_rule(self.neutron_client,
1308                                              'sg_id',
1309                                              'direction',
1310                                              'protocol'))
1311
1312     @mock.patch('functest.utils.openstack_utils.logger.error')
1313     def test_create_secgroup_rule_invalid_port_range(self, mock_logger_error):
1314         self.assertFalse(openstack_utils.
1315                          create_secgroup_rule(self.neutron_client,
1316                                               'sg_id',
1317                                               'direction',
1318                                               'protocol',
1319                                               80))
1320
1321     @mock.patch('functest.utils.openstack_utils.logger.error')
1322     def test_create_secgroup_rule_exception(self, mock_logger_error):
1323         self.assertFalse(openstack_utils.
1324                          create_secgroup_rule(Exception,
1325                                               'sg_id',
1326                                               'direction',
1327                                               'protocol'))
1328
1329     @mock.patch('functest.utils.openstack_utils.logger.info')
1330     def test_create_security_group_full_default(self, mock_logger_info):
1331         with mock.patch('functest.utils.openstack_utils.'
1332                         'get_security_group_id',
1333                         return_value='sg_id'):
1334             self.assertEqual(openstack_utils.
1335                              create_security_group_full(self.neutron_client,
1336                                                         'sg_name',
1337                                                         'sg_desc'),
1338                              'sg_id')
1339             self.assertTrue(mock_logger_info)
1340
1341     @mock.patch('functest.utils.openstack_utils.logger.info')
1342     @mock.patch('functest.utils.openstack_utils.logger.error')
1343     def test_create_security_group_full_sec_group_fail(self,
1344                                                        mock_logger_error,
1345                                                        mock_logger_info):
1346         with mock.patch('functest.utils.openstack_utils.'
1347                         'get_security_group_id',
1348                         return_value=''), \
1349             mock.patch('functest.utils.openstack_utils.'
1350                        'create_security_group',
1351                        return_value=False):
1352             self.assertEqual(openstack_utils.
1353                              create_security_group_full(self.neutron_client,
1354                                                         'sg_name',
1355                                                         'sg_desc'),
1356                              None)
1357             self.assertTrue(mock_logger_error)
1358             self.assertTrue(mock_logger_info)
1359
1360     @mock.patch('functest.utils.openstack_utils.logger.debug')
1361     @mock.patch('functest.utils.openstack_utils.logger.info')
1362     @mock.patch('functest.utils.openstack_utils.logger.error')
1363     def test_create_security_group_full_secgroup_rule_fail(self,
1364                                                            mock_logger_error,
1365                                                            mock_logger_info,
1366                                                            mock_logger_debug):
1367         with mock.patch('functest.utils.openstack_utils.'
1368                         'get_security_group_id',
1369                         return_value=''), \
1370             mock.patch('functest.utils.openstack_utils.'
1371                        'create_security_group',
1372                        return_value={'id': 'sg_id',
1373                                      'name': 'sg_name'}), \
1374             mock.patch('functest.utils.openstack_utils.'
1375                        'create_secgroup_rule',
1376                        return_value=False):
1377             self.assertEqual(openstack_utils.
1378                              create_security_group_full(self.neutron_client,
1379                                                         'sg_name',
1380                                                         'sg_desc'),
1381                              None)
1382             self.assertTrue(mock_logger_error)
1383             self.assertTrue(mock_logger_info)
1384             self.assertTrue(mock_logger_debug)
1385
1386     def test_add_secgroup_to_instance_default(self):
1387         self.assertTrue(openstack_utils.
1388                         add_secgroup_to_instance(self.nova_client,
1389                                                  'instance_id',
1390                                                  'sec_group_id'))
1391
1392     @mock.patch('functest.utils.openstack_utils.logger.error')
1393     def test_add_secgroup_to_instance_exception(self, mock_logger_error):
1394         self.assertFalse(openstack_utils.
1395                          add_secgroup_to_instance(Exception,
1396                                                   'instance_id',
1397                                                   'sec_group_id'))
1398         self.assertTrue(mock_logger_error.called)
1399
1400     def test_update_sg_quota_default(self):
1401         self.assertTrue(openstack_utils.
1402                         update_sg_quota(self.neutron_client,
1403                                         'tenant_id',
1404                                         'sg_quota',
1405                                         'sg_rule_quota'))
1406
1407     @mock.patch('functest.utils.openstack_utils.logger.error')
1408     def test_update_sg_quota_exception(self, mock_logger_error):
1409         self.assertFalse(openstack_utils.
1410                          update_sg_quota(Exception,
1411                                          'tenant_id',
1412                                          'sg_quota',
1413                                          'sg_rule_quota'))
1414         self.assertTrue(mock_logger_error.called)
1415
1416     def test_delete_security_group_default(self):
1417         self.assertTrue(openstack_utils.
1418                         delete_security_group(self.neutron_client,
1419                                               'sec_group_id'))
1420
1421     @mock.patch('functest.utils.openstack_utils.logger.error')
1422     def test_delete_security_group_exception(self, mock_logger_error):
1423         self.assertFalse(openstack_utils.
1424                          delete_security_group(Exception,
1425                                                'sec_group_id'))
1426         self.assertTrue(mock_logger_error.called)
1427
1428     def test_get_images_default(self):
1429         self.assertEqual(openstack_utils.
1430                          get_images(self.glance_client),
1431                          [self.image])
1432
1433     @mock.patch('functest.utils.openstack_utils.logger.error')
1434     def test_get_images_exception(self, mock_logger_error):
1435         self.assertEqual(openstack_utils.
1436                          get_images(Exception),
1437                          None)
1438         self.assertTrue(mock_logger_error.called)
1439
1440     def test_get_image_id_default(self):
1441         self.assertEqual(openstack_utils.
1442                          get_image_id(self.glance_client,
1443                                       'test_image'),
1444                          'image_id')
1445
1446     # create_glance_image, get_or_create_image
1447     @mock.patch('functest.utils.openstack_utils.logger.error')
1448     def test_create_glance_image_file_present(self, mock_logger_error):
1449         with mock.patch('functest.utils.openstack_utils.'
1450                         'os.path.isfile',
1451                         return_value=False):
1452             self.assertEqual(openstack_utils.
1453                              create_glance_image(self.glance_client,
1454                                                  'test_image',
1455                                                  'file_path'),
1456                              None)
1457             self.assertTrue(mock_logger_error.called)
1458
1459     @mock.patch('functest.utils.openstack_utils.logger.info')
1460     def test_create_glance_image_already_exist(self, mock_logger_info):
1461         with mock.patch('functest.utils.openstack_utils.'
1462                         'os.path.isfile',
1463                         return_value=True), \
1464             mock.patch('functest.utils.openstack_utils.get_image_id',
1465                        return_value='image_id'):
1466                 self.assertEqual(openstack_utils.
1467                                  create_glance_image(self.glance_client,
1468                                                      'test_image',
1469                                                      'file_path'),
1470                                  'image_id')
1471                 self.assertTrue(mock_logger_info.called)
1472
1473     @mock.patch('functest.utils.openstack_utils.logger.info')
1474     def test_create_glance_image_default(self, mock_logger_info):
1475         with mock.patch('functest.utils.openstack_utils.'
1476                         'os.path.isfile',
1477                         return_value=True), \
1478             mock.patch('functest.utils.openstack_utils.get_image_id',
1479                        return_value=''), \
1480             mock.patch('__builtin__.open',
1481                        mock.mock_open(read_data='1')) as m:
1482                 self.assertEqual(openstack_utils.
1483                                  create_glance_image(self.glance_client,
1484                                                      'test_image',
1485                                                      'file_path'),
1486                                  'image_id')
1487                 m.assert_called_once_with('file_path')
1488                 self.assertTrue(mock_logger_info.called)
1489
1490     @mock.patch('functest.utils.openstack_utils.logger.error')
1491     def test_create_glance_image_exception(self, mock_logger_error):
1492         with mock.patch('functest.utils.openstack_utils.'
1493                         'os.path.isfile',
1494                         return_value=True), \
1495             mock.patch('functest.utils.openstack_utils.get_image_id',
1496                        side_effect=Exception):
1497                 self.assertEqual(openstack_utils.
1498                                  create_glance_image(self.glance_client,
1499                                                      'test_image',
1500                                                      'file_path'),
1501                                  None)
1502                 self.assertTrue(mock_logger_error.called)
1503
1504     def test_delete_glance_image_default(self):
1505         self.assertTrue(openstack_utils.
1506                         delete_glance_image(self.nova_client,
1507                                             'image_id'))
1508
1509     @mock.patch('functest.utils.openstack_utils.logger.error')
1510     def test_delete_glance_image_exception(self, mock_logger_error):
1511         self.assertFalse(openstack_utils.
1512                          delete_glance_image(Exception,
1513                                              'image_id'))
1514         self.assertTrue(mock_logger_error.called)
1515
1516     def test_get_volumes_default(self):
1517         self.assertEqual(openstack_utils.
1518                          get_volumes(self.cinder_client),
1519                          [self.volume])
1520
1521     @mock.patch('functest.utils.openstack_utils.logger.error')
1522     def test_get_volumes_exception(self, mock_logger_error):
1523         self.assertEqual(openstack_utils.
1524                          get_volumes(Exception),
1525                          None)
1526         self.assertTrue(mock_logger_error.called)
1527
1528     def test_list_volume_types_default_private(self):
1529         self.assertEqual(openstack_utils.
1530                          list_volume_types(self.cinder_client,
1531                                            public=False,
1532                                            private=True),
1533                          [self.volume_types[1]])
1534
1535     def test_list_volume_types_default_public(self):
1536         self.assertEqual(openstack_utils.
1537                          list_volume_types(self.cinder_client,
1538                                            public=True,
1539                                            private=False),
1540                          [self.volume_types[0]])
1541
1542     @mock.patch('functest.utils.openstack_utils.logger.error')
1543     def test_list_volume_types_exception(self, mock_logger_error):
1544         self.assertEqual(openstack_utils.
1545                          list_volume_types(Exception),
1546                          None)
1547         self.assertTrue(mock_logger_error.called)
1548
1549     def test_create_volume_type_default(self):
1550         self.assertEqual(openstack_utils.
1551                          create_volume_type(self.cinder_client,
1552                                             'test_volume_type'),
1553                          self.volume_types[0])
1554
1555     @mock.patch('functest.utils.openstack_utils.logger.error')
1556     def test_create_volume_type_exception(self, mock_logger_error):
1557         self.assertEqual(openstack_utils.
1558                          create_volume_type(Exception,
1559                                             'test_volume_type'),
1560                          None)
1561         self.assertTrue(mock_logger_error.called)
1562
1563     def test_update_cinder_quota_default(self):
1564         self.assertTrue(openstack_utils.
1565                         update_cinder_quota(self.cinder_client,
1566                                             'tenant_id',
1567                                             'vols_quota',
1568                                             'snap_quota',
1569                                             'giga_quota'))
1570
1571     @mock.patch('functest.utils.openstack_utils.logger.error')
1572     def test_update_cinder_quota_exception(self, mock_logger_error):
1573         self.assertFalse(openstack_utils.
1574                          update_cinder_quota(Exception,
1575                                              'tenant_id',
1576                                              'vols_quota',
1577                                              'snap_quota',
1578                                              'giga_quota'))
1579         self.assertTrue(mock_logger_error.called)
1580
1581     def test_delete_volume_default(self):
1582         self.assertTrue(openstack_utils.
1583                         delete_volume(self.cinder_client,
1584                                       'volume_id',
1585                                       forced=False))
1586
1587         self.assertTrue(openstack_utils.
1588                         delete_volume(self.cinder_client,
1589                                       'volume_id',
1590                                       forced=True))
1591
1592     @mock.patch('functest.utils.openstack_utils.logger.error')
1593     def test_delete_volume_exception(self, mock_logger_error):
1594         self.assertFalse(openstack_utils.
1595                          delete_volume(Exception,
1596                                        'volume_id',
1597                                        forced=True))
1598         self.assertTrue(mock_logger_error.called)
1599
1600     def test_delete_volume_type_default(self):
1601         self.assertTrue(openstack_utils.
1602                         delete_volume_type(self.cinder_client,
1603                                            self.volume_types[0]))
1604
1605     @mock.patch('functest.utils.openstack_utils.logger.error')
1606     def test_delete_volume_type_exception(self, mock_logger_error):
1607         self.assertFalse(openstack_utils.
1608                          delete_volume_type(Exception,
1609                                             self.volume_types[0]))
1610         self.assertTrue(mock_logger_error.called)
1611
1612     def test_get_tenants_default(self):
1613         with mock.patch('functest.utils.openstack_utils.'
1614                         'is_keystone_v3', return_value=True):
1615             self.assertEqual(openstack_utils.
1616                              get_tenants(self.keystone_client),
1617                              [self.tenant])
1618         with mock.patch('functest.utils.openstack_utils.'
1619                         'is_keystone_v3', return_value=False):
1620             self.assertEqual(openstack_utils.
1621                              get_tenants(self.keystone_client),
1622                              [self.tenant])
1623
1624     @mock.patch('functest.utils.openstack_utils.logger.error')
1625     def test_get_tenants_exception(self, mock_logger_error):
1626         self.assertEqual(openstack_utils.
1627                          get_tenants(Exception),
1628                          None)
1629         self.assertTrue(mock_logger_error.called)
1630
1631     def test_get_users_default(self):
1632         self.assertEqual(openstack_utils.
1633                          get_users(self.keystone_client),
1634                          [self.user])
1635
1636     @mock.patch('functest.utils.openstack_utils.logger.error')
1637     def test_get_users_exception(self, mock_logger_error):
1638         self.assertEqual(openstack_utils.
1639                          get_users(Exception),
1640                          None)
1641         self.assertTrue(mock_logger_error.called)
1642
1643     def test_get_tenant_id_default(self):
1644         self.assertEqual(openstack_utils.
1645                          get_tenant_id(self.keystone_client,
1646                                        'test_tenant'),
1647                          'tenant_id')
1648
1649     def test_get_user_id_default(self):
1650         self.assertEqual(openstack_utils.
1651                          get_user_id(self.keystone_client,
1652                                      'test_user'),
1653                          'user_id')
1654
1655     def test_get_role_id_default(self):
1656         self.assertEqual(openstack_utils.
1657                          get_role_id(self.keystone_client,
1658                                      'test_role'),
1659                          'role_id')
1660
1661     def test_get_domain_id_default(self):
1662         self.assertEqual(openstack_utils.
1663                          get_domain_id(self.keystone_client,
1664                                        'test_domain'),
1665                          'domain_id')
1666
1667     def test_create_tenant_default(self):
1668         with mock.patch('functest.utils.openstack_utils.'
1669                         'is_keystone_v3', return_value=True):
1670             CONST.__setattr__('OS_PROJECT_DOMAIN_NAME', 'Default')
1671             self.assertEqual(openstack_utils.
1672                              create_tenant(self.keystone_client,
1673                                            'test_tenant',
1674                                            'tenant_desc'),
1675                              'tenant_id')
1676         with mock.patch('functest.utils.openstack_utils.'
1677                         'is_keystone_v3', return_value=False):
1678             self.assertEqual(openstack_utils.
1679                              create_tenant(self.keystone_client,
1680                                            'test_tenant',
1681                                            'tenant_desc'),
1682                              'tenant_id')
1683
1684     @mock.patch('functest.utils.openstack_utils.logger.error')
1685     def test_create_tenant_exception(self, mock_logger_error):
1686         self.assertEqual(openstack_utils.
1687                          create_tenant(Exception,
1688                                        'test_tenant',
1689                                        'tenant_desc'),
1690                          None)
1691         self.assertTrue(mock_logger_error.called)
1692
1693     def test_create_user_default(self):
1694         with mock.patch('functest.utils.openstack_utils.'
1695                         'is_keystone_v3', return_value=True):
1696             self.assertEqual(openstack_utils.
1697                              create_user(self.keystone_client,
1698                                          'test_user',
1699                                          'password',
1700                                          'email',
1701                                          'tenant_id'),
1702                              'user_id')
1703         with mock.patch('functest.utils.openstack_utils.'
1704                         'is_keystone_v3', return_value=False):
1705             self.assertEqual(openstack_utils.
1706                              create_user(self.keystone_client,
1707                                          'test_user',
1708                                          'password',
1709                                          'email',
1710                                          'tenant_id'),
1711                              'user_id')
1712
1713     @mock.patch('functest.utils.openstack_utils.logger.error')
1714     def test_create_user_exception(self, mock_logger_error):
1715         self.assertEqual(openstack_utils.
1716                          create_user(Exception,
1717                                      'test_user',
1718                                      'password',
1719                                      'email',
1720                                      'tenant_id'),
1721                          None)
1722         self.assertTrue(mock_logger_error.called)
1723
1724     def test_add_role_user_default(self):
1725         with mock.patch('functest.utils.openstack_utils.'
1726                         'is_keystone_v3', return_value=True):
1727             self.assertTrue(openstack_utils.
1728                             add_role_user(self.keystone_client,
1729                                           'user_id',
1730                                           'role_id',
1731                                           'tenant_id'))
1732
1733         with mock.patch('functest.utils.openstack_utils.'
1734                         'is_keystone_v3', return_value=False):
1735             self.assertTrue(openstack_utils.
1736                             add_role_user(self.keystone_client,
1737                                           'user_id',
1738                                           'role_id',
1739                                           'tenant_id'))
1740
1741     @mock.patch('functest.utils.openstack_utils.logger.error')
1742     def test_add_role_user_exception(self, mock_logger_error):
1743         self.assertFalse(openstack_utils.
1744                          add_role_user(Exception,
1745                                        'user_id',
1746                                        'role_id',
1747                                        'tenant_id'))
1748         self.assertTrue(mock_logger_error.called)
1749
1750     def test_delete_tenant_default(self):
1751         with mock.patch('functest.utils.openstack_utils.'
1752                         'is_keystone_v3', return_value=True):
1753             self.assertTrue(openstack_utils.
1754                             delete_tenant(self.keystone_client,
1755                                           'tenant_id'))
1756
1757         with mock.patch('functest.utils.openstack_utils.'
1758                         'is_keystone_v3', return_value=False):
1759             self.assertTrue(openstack_utils.
1760                             delete_tenant(self.keystone_client,
1761                                           'tenant_id'))
1762
1763     @mock.patch('functest.utils.openstack_utils.logger.error')
1764     def test_delete_tenant_exception(self, mock_logger_error):
1765         self.assertFalse(openstack_utils.
1766                          delete_tenant(Exception,
1767                                        'tenant_id'))
1768         self.assertTrue(mock_logger_error.called)
1769
1770     def test_delete_user_default(self):
1771         self.assertTrue(openstack_utils.
1772                         delete_user(self.keystone_client,
1773                                     'user_id'))
1774
1775     @mock.patch('functest.utils.openstack_utils.logger.error')
1776     def test_delete_user_exception(self, mock_logger_error):
1777         self.assertFalse(openstack_utils.
1778                          delete_user(Exception,
1779                                      'user_id'))
1780         self.assertTrue(mock_logger_error.called)
1781
1782     def test_get_resource_default(self):
1783         with mock.patch('functest.utils.openstack_utils.'
1784                         'is_keystone_v3', return_value=True):
1785             self.assertEqual(openstack_utils.
1786                              get_resource(self.heat_client,
1787                                           'stack_id',
1788                                           'resource'),
1789                              self.resource)
1790
1791     @mock.patch('functest.utils.openstack_utils.logger.error')
1792     def test_get_resource_exception(self, mock_logger_error):
1793         self.assertEqual(openstack_utils.
1794                          get_resource(Exception,
1795                                       'stack_id',
1796                                       'resource'),
1797                          None)
1798         self.assertTrue(mock_logger_error.called)
1799
1800     def test_get_or_create_user_for_vnf_get(self):
1801         with mock.patch('functest.utils.openstack_utils.'
1802                         'get_user_id',
1803                         return_value='user_id'), \
1804             mock.patch('functest.utils.openstack_utils.get_tenant_id',
1805                        return_value='tenant_id'):
1806             self.assertFalse(openstack_utils.
1807                              get_or_create_user_for_vnf(self.keystone_client,
1808                                                         'my_vnf'))
1809
1810     def test_get_or_create_user_for_vnf_create(self):
1811         with mock.patch('functest.utils.openstack_utils.'
1812                         'get_user_id',
1813                         return_value=None), \
1814             mock.patch('functest.utils.openstack_utils.get_tenant_id',
1815                        return_value='tenant_id'):
1816             self.assertTrue(openstack_utils.
1817                             get_or_create_user_for_vnf(self.keystone_client,
1818                                                        'my_vnf'))
1819
1820     def test_get_or_create_user_for_vnf_error_get_user_id(self):
1821         with mock.patch('functest.utils.openstack_utils.'
1822                         'get_user_id',
1823                         side_effect=Exception):
1824             self.assertRaises(Exception)
1825
1826     def test_get_or_create_user_for_vnf_error_get_tenant_id(self):
1827         with mock.patch('functest.utils.openstack_utils.'
1828                         'get_user_id',
1829                         return_value='user_id'), \
1830             mock.patch('functest.utils.openstack_utils.get_tenant_id',
1831                        side_effect='Exception'):
1832             self.assertRaises(Exception)
1833
1834     def test_get_or_create_tenant_for_vnf_get(self):
1835         with mock.patch('functest.utils.openstack_utils.'
1836                         'get_tenant_id',
1837                         return_value='tenant_id'):
1838             self.assertFalse(
1839                 openstack_utils.get_or_create_tenant_for_vnf(
1840                     self.keystone_client, 'tenant_name', 'tenant_description'))
1841
1842     def test_get_or_create_tenant_for_vnf_create(self):
1843         with mock.patch('functest.utils.openstack_utils.get_tenant_id',
1844                         return_value=None):
1845             self.assertTrue(
1846                 openstack_utils.get_or_create_tenant_for_vnf(
1847                     self.keystone_client, 'tenant_name', 'tenant_description'))
1848
1849     def test_get_or_create_tenant_for_vnf_error_get_tenant_id(self):
1850         with mock.patch('functest.utils.openstack_utils.'
1851                         'get_tenant_id',
1852                         side_effect=Exception):
1853             self.assertRaises(Exception)
1854
1855     def test_download_and_add_image_on_glance_image_creation_failure(self):
1856         with mock.patch('functest.utils.openstack_utils.'
1857                         'os.makedirs'), \
1858             mock.patch('functest.utils.openstack_utils.'
1859                        'ft_utils.download_url',
1860                        return_value=True), \
1861             mock.patch('functest.utils.openstack_utils.'
1862                        'create_glance_image',
1863                        return_value=''):
1864             resp = openstack_utils.download_and_add_image_on_glance(
1865                 self.glance_client,
1866                 'image_name',
1867                 'http://url',
1868                 'data_dir')
1869             self.assertEqual(resp, False)
1870
1871
1872 if __name__ == "__main__":
1873     logging.disable(logging.CRITICAL)
1874     unittest.main(verbosity=2)