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