functest/tests/unit/utils/test_openstack_utils.py

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