Remove openstack utils

They have been obsolete since we fully switched to snaps.
The files are being moved to SDNVPN which is the last project using
them [1].

[1] https://gerrit.opnfv.org/gerrit/#/c/52631/

Change-Id: I277b92a04cf6bc7b30015eed76f03f17830fad2b
Signed-off-by: Cédric Ollivier <cedric.ollivier@orange.com>

1 files changed, 0 insertions, 1784 deletions

diff --git a/functest/tests/unit/utils/test_openstack_utils.py b/functest/tests/unit/utils/test_openstack_utils.py
deleted file mode 100644
index 259e60d5..00000000
--- a/functest/tests/unit/utils/test_openstack_utils.py
+++ /dev/null
@@ -1,1784 +0,0 @@
-#!/usr/bin/env python
-
-# All rights reserved. This program and the accompanying materials
-# are made available under the terms of the Apache License, Version 2.0
-# which accompanies this distribution, and is available at
-# http://www.apache.org/licenses/LICENSE-2.0
-
-# pylint: disable=missing-docstring
-
-import copy
-import logging
-import os
-import unittest
-
-import mock
-
-from functest.utils import openstack_utils
-
-
-class OSUtilsTesting(unittest.TestCase):
-
-    def _get_env_cred_dict(self, os_prefix=''):
-        return {'OS_USERNAME': os_prefix + 'username',
-                'OS_PASSWORD': os_prefix + 'password',
-                'OS_AUTH_URL': os_prefix + 'auth_url',
-                'OS_TENANT_NAME': os_prefix + 'tenant_name',
-                'OS_USER_DOMAIN_NAME': os_prefix + 'user_domain_name',
-                'OS_PROJECT_DOMAIN_NAME': os_prefix + 'project_domain_name',
-                'OS_PROJECT_NAME': os_prefix + 'project_name',
-                'OS_ENDPOINT_TYPE': os_prefix + 'endpoint_type',
-                'OS_REGION_NAME': os_prefix + 'region_name',
-                'OS_CACERT': os_prefix + 'https_cacert',
-                'OS_INSECURE': os_prefix + 'https_insecure'}
-
-    def _get_os_env_vars(self):
-        return {'username': 'test_username', 'password': 'test_password',
-                'auth_url': 'test_auth_url', 'tenant_name': 'test_tenant_name',
-                'user_domain_name': 'test_user_domain_name',
-                'project_domain_name': 'test_project_domain_name',
-                'project_name': 'test_project_name',
-                'endpoint_type': 'test_endpoint_type',
-                'region_name': 'test_region_name',
-                'https_cacert': 'test_https_cacert',
-                'https_insecure': 'test_https_insecure'}
-
-    def setUp(self):
-        self.env_vars = ['OS_AUTH_URL', 'OS_USERNAME', 'OS_PASSWORD']
-        self.tenant_name = 'test_tenant_name'
-        self.env_cred_dict = self._get_env_cred_dict()
-        self.os_environs = self._get_env_cred_dict(os_prefix='test_')
-        self.os_env_vars = self._get_os_env_vars()
-
-        mock_obj = mock.Mock()
-        attrs = {'name': 'test_flavor',
-                 'id': 'flavor_id',
-                 'ram': 2}
-        mock_obj.configure_mock(**attrs)
-        self.flavor = mock_obj
-
-        mock_obj = mock.Mock()
-        attrs = {'name': 'test_aggregate',
-                 'id': 'aggregate_id',
-                 'hosts': ['host_name']}
-        mock_obj.configure_mock(**attrs)
-        self.aggregate = mock_obj
-
-        mock_obj = mock.Mock()
-        attrs = {'id': 'instance_id',
-                 'name': 'test_instance',
-                 'status': 'ok'}
-        mock_obj.configure_mock(**attrs)
-        self.instance = mock_obj
-
-        mock_obj = mock.Mock()
-        attrs = {'id': 'azone_id',
-                 'zoneName': 'test_azone',
-                 'status': 'ok'}
-        mock_obj.configure_mock(**attrs)
-        self.availability_zone = mock_obj
-
-        mock_obj = mock.Mock()
-        attrs = {'floating_network_id': 'floating_id',
-                 'floating_ip_address': 'test_floating_ip'}
-        mock_obj.configure_mock(**attrs)
-        self.floating_ip = mock_obj
-
-        mock_obj = mock.Mock()
-        attrs = {'id': 'hypervisor_id',
-                 'hypervisor_hostname': 'test_hostname',
-                 'state': 'up'}
-        mock_obj.configure_mock(**attrs)
-        self.hypervisor = mock_obj
-
-        mock_obj = mock.Mock()
-        attrs = {'id': 'image_id',
-                 'name': 'test_image'}
-        mock_obj.configure_mock(**attrs)
-        self.image = mock_obj
-
-        mock_obj = mock.Mock()
-        self.mock_return = mock_obj
-
-        self.nova_client = mock.Mock()
-        attrs = {'servers.list.return_value': [self.instance],
-                 'servers.get.return_value': self.instance,
-                 'servers.find.return_value': self.instance,
-                 'servers.create.return_value': self.instance,
-                 'flavors.list.return_value': [self.flavor],
-                 'flavors.find.return_value': self.flavor,
-                 'servers.add_floating_ip.return_value': mock.Mock(),
-                 'servers.force_delete.return_value': mock.Mock(),
-                 'aggregates.list.return_value': [self.aggregate],
-                 'aggregates.add_host.return_value': mock.Mock(),
-                 'aggregates.remove_host.return_value': mock.Mock(),
-                 'aggregates.get.return_value': self.aggregate,
-                 'aggregates.delete.return_value': mock.Mock(),
-                 'availability_zones.list.return_value':
-                 [self.availability_zone],
-                 'hypervisors.list.return_value': [self.hypervisor],
-                 'create.return_value': mock.Mock(),
-                 'add_security_group.return_value': mock.Mock(),
-                 'images.list.return_value': [self.image],
-                 'images.delete.return_value': mock.Mock(),
-                 }
-        self.nova_client.configure_mock(**attrs)
-
-        self.glance_client = mock.Mock()
-        attrs = {'images.list.return_value': [self.image],
-                 'images.create.return_value': self.image,
-                 'images.upload.return_value': mock.Mock()}
-        self.glance_client.configure_mock(**attrs)
-
-        mock_obj = mock.Mock()
-        attrs = {'id': 'volume_id',
-                 'name': 'test_volume'}
-        mock_obj.configure_mock(**attrs)
-        self.volume = mock_obj
-
-        self.cinder_client = mock.Mock()
-        attrs = {'volumes.list.return_value': [self.volume],
-                 'quotas.update.return_value': mock.Mock(),
-                 'volumes.detach.return_value': mock.Mock(),
-                 'volumes.force_delete.return_value': mock.Mock(),
-                 'volumes.delete.return_value': mock.Mock()
-                 }
-        self.cinder_client.configure_mock(**attrs)
-
-        self.resource = mock.Mock()
-        attrs = {'id': 'resource_test_id',
-                 'name': 'resource_test_name'
-                 }
-
-        self.heat_client = mock.Mock()
-        attrs = {'resources.get.return_value': self.resource}
-        self.heat_client.configure_mock(**attrs)
-
-        mock_obj = mock.Mock()
-        attrs = {'id': 'tenant_id',
-                 'name': 'test_tenant'}
-        mock_obj.configure_mock(**attrs)
-        self.tenant = mock_obj
-
-        mock_obj = mock.Mock()
-        attrs = {'id': 'user_id',
-                 'name': 'test_user'}
-        mock_obj.configure_mock(**attrs)
-        self.user = mock_obj
-
-        mock_obj = mock.Mock()
-        attrs = {'id': 'role_id',
-                 'name': 'test_role'}
-        mock_obj.configure_mock(**attrs)
-        self.role = mock_obj
-
-        mock_obj = mock.Mock()
-        attrs = {'id': 'domain_id',
-                 'name': 'test_domain'}
-        mock_obj.configure_mock(**attrs)
-        self.domain = mock_obj
-
-        self.keystone_client = mock.Mock()
-        attrs = {'projects.list.return_value': [self.tenant],
-                 'tenants.list.return_value': [self.tenant],
-                 'users.list.return_value': [self.user],
-                 'roles.list.return_value': [self.role],
-                 'domains.list.return_value': [self.domain],
-                 'projects.create.return_value': self.tenant,
-                 'tenants.create.return_value': self.tenant,
-                 'users.create.return_value': self.user,
-                 'roles.grant.return_value': mock.Mock(),
-                 'roles.add_user_role.return_value': mock.Mock(),
-                 'projects.delete.return_value': mock.Mock(),
-                 'tenants.delete.return_value': mock.Mock(),
-                 'users.delete.return_value': mock.Mock(),
-                 }
-        self.keystone_client.configure_mock(**attrs)
-
-        self.router = {'id': 'router_id',
-                       'name': 'test_router'}
-
-        self.subnet = {'id': 'subnet_id',
-                       'name': 'test_subnet'}
-
-        self.networks = [{'id': 'network_id',
-                          'name': 'test_network',
-                          'router:external': False,
-                          'shared': True,
-                          'subnets': [self.subnet]},
-                         {'id': 'network_id1',
-                          'name': 'test_network1',
-                          'router:external': True,
-                          'shared': True,
-                          'subnets': [self.subnet]}]
-
-        self.port = {'id': 'port_id',
-                     'name': 'test_port'}
-
-        self.sec_group = {'id': 'sec_group_id',
-                          'name': 'test_sec_group'}
-
-        self.sec_group_rule = {'id': 'sec_group_rule_id',
-                               'direction': 'direction',
-                               'protocol': 'protocol',
-                               'port_range_max': 'port_max',
-                               'security_group_id': self.sec_group['id'],
-                               'port_range_min': 'port_min'}
-        self.neutron_floatingip = {'id': 'fip_id',
-                                   'floating_ip_address': 'test_ip'}
-        self.neutron_client = mock.Mock()
-        attrs = {'list_networks.return_value': {'networks': self.networks},
-                 'list_routers.return_value': {'routers': [self.router]},
-                 'list_ports.return_value': {'ports': [self.port]},
-                 'list_subnets.return_value': {'subnets': [self.subnet]},
-                 'create_network.return_value': {'network': self.networks[0]},
-                 'create_subnet.return_value': {'subnets': [self.subnet]},
-                 'create_router.return_value': {'router': self.router},
-                 'create_port.return_value': {'port': self.port},
-                 'create_floatingip.return_value': {'floatingip':
-                                                    self.neutron_floatingip},
-                 'update_network.return_value': mock.Mock(),
-                 'update_port.return_value': {'port': self.port},
-                 'add_interface_router.return_value': mock.Mock(),
-                 'add_gateway_router.return_value': mock.Mock(),
-                 'delete_network.return_value': mock.Mock(),
-                 'delete_subnet.return_value': mock.Mock(),
-                 'delete_router.return_value': mock.Mock(),
-                 'delete_port.return_value': mock.Mock(),
-                 'remove_interface_router.return_value': mock.Mock(),
-                 'remove_gateway_router.return_value': mock.Mock(),
-                 'list_security_groups.return_value': {'security_groups':
-                                                       [self.sec_group]},
-                 'list_security_group_rules.'
-                 'return_value': {'security_group_rules':
-                                  [self.sec_group_rule]},
-                 'create_security_group_rule.return_value': mock.Mock(),
-                 'create_security_group.return_value': {'security_group':
-                                                        self.sec_group},
-                 'update_quota.return_value': mock.Mock(),
-                 'delete_security_group.return_value': mock.Mock(),
-                 'list_floatingips.return_value': {'floatingips':
-                                                   [self.floating_ip]},
-                 'delete_floatingip.return_value': mock.Mock(),
-                 }
-        self.neutron_client.configure_mock(**attrs)
-
-        self.empty_client = mock.Mock()
-        attrs = {'list_networks.return_value': {'networks': []},
-                 'list_routers.return_value': {'routers': []},
-                 'list_ports.return_value': {'ports': []},
-                 'list_subnets.return_value': {'subnets': []}}
-        self.empty_client.configure_mock(**attrs)
-
-    @mock.patch('functest.utils.openstack_utils.os.getenv',
-                return_value=None)
-    def test_is_keystone_v3_missing_identity(self, mock_os_getenv):
-        self.assertEqual(openstack_utils.is_keystone_v3(), False)
-
-    @mock.patch('functest.utils.openstack_utils.os.getenv',
-                return_value='3')
-    def test_is_keystone_v3_default(self, mock_os_getenv):
-        self.assertEqual(openstack_utils.is_keystone_v3(), True)
-
-    @mock.patch('functest.utils.openstack_utils.is_keystone_v3',
-                return_value=False)
-    def test_get_rc_env_vars_missing_identity(self, mock_get_rc_env):
-        exp_resp = self.env_vars
-        exp_resp.extend(['OS_TENANT_NAME'])
-        self.assertEqual(openstack_utils.get_rc_env_vars(), exp_resp)
-
-    @mock.patch('functest.utils.openstack_utils.is_keystone_v3',
-                return_value=True)
-    def test_get_rc_env_vars_default(self, mock_get_rc_env):
-        exp_resp = self.env_vars
-        exp_resp.extend(['OS_PROJECT_NAME',
-                         'OS_USER_DOMAIN_NAME',
-                         'OS_PROJECT_DOMAIN_NAME'])
-        self.assertEqual(openstack_utils.get_rc_env_vars(), exp_resp)
-
-    @mock.patch('functest.utils.openstack_utils.get_rc_env_vars')
-    def test_check_credentials_missing_env(self, mock_get_rc_env):
-        exp_resp = self.env_vars
-        exp_resp.extend(['OS_TENANT_NAME'])
-        mock_get_rc_env.return_value = exp_resp
-        with mock.patch.dict('functest.utils.openstack_utils.os.environ', {},
-                             clear=True):
-            self.assertEqual(openstack_utils.check_credentials(), False)
-
-    @mock.patch('functest.utils.openstack_utils.get_rc_env_vars')
-    def test_check_credentials_default(self, mock_get_rc_env):
-        exp_resp = ['OS_TENANT_NAME']
-        mock_get_rc_env.return_value = exp_resp
-        with mock.patch.dict('functest.utils.openstack_utils.os.environ',
-                             {'OS_TENANT_NAME': self.tenant_name},
-                             clear=True):
-            self.assertEqual(openstack_utils.check_credentials(), True)
-
-    def test_get_env_cred_dict(self):
-        self.assertDictEqual(openstack_utils.get_env_cred_dict(),
-                             self.env_cred_dict)
-
-    @mock.patch('functest.utils.openstack_utils.get_rc_env_vars')
-    def test_get_credentials_default(self, mock_get_rc_env):
-        mock_get_rc_env.return_value = self.env_cred_dict.keys()
-        with mock.patch.dict('functest.utils.openstack_utils.os.environ',
-                             self.os_environs,
-                             clear=True):
-            self.assertDictEqual(openstack_utils.get_credentials(),
-                                 self.os_env_vars)
-
-    def _get_credentials_missing_env(self, var):
-        dic = copy.deepcopy(self.os_environs)
-        dic.pop(var)
-        with mock.patch('functest.utils.openstack_utils.get_rc_env_vars',
-                        return_value=self.env_cred_dict.keys()), \
-                mock.patch.dict('functest.utils.openstack_utils.os.environ',
-                                dic,
-                                clear=True):
-            self.assertRaises(openstack_utils.MissingEnvVar,
-                              lambda: openstack_utils.get_credentials())
-
-    def test_get_credentials_missing_username(self):
-        self._get_credentials_missing_env('OS_USERNAME')
-
-    def test_get_credentials_missing_password(self):
-        self._get_credentials_missing_env('OS_PASSWORD')
-
-    def test_get_credentials_missing_auth_url(self):
-        self._get_credentials_missing_env('OS_AUTH_URL')
-
-    def test_get_credentials_missing_tenantname(self):
-        self._get_credentials_missing_env('OS_TENANT_NAME')
-
-    def test_get_credentials_missing_domainname(self):
-        self._get_credentials_missing_env('OS_USER_DOMAIN_NAME')
-
-    def test_get_credentials_missing_projectname(self):
-        self._get_credentials_missing_env('OS_PROJECT_NAME')
-
-    def test_get_credentials_missing_endpoint_type(self):
-        self._get_credentials_missing_env('OS_ENDPOINT_TYPE')
-
-    @mock.patch('functest.utils.openstack_utils.os.getenv',
-                return_value=None)
-    def test_get_keystone_client_version_missing_env(self, mock_os_getenv):
-        self.assertEqual(openstack_utils.get_keystone_client_version(),
-                         openstack_utils.DEFAULT_API_VERSION)
-
-    @mock.patch('functest.utils.openstack_utils.logger.info')
-    @mock.patch('functest.utils.openstack_utils.os.getenv',
-                return_value='3')
-    def test_get_keystone_client_version_default(self, mock_os_getenv,
-                                                 mock_logger_info):
-        self.assertEqual(openstack_utils.get_keystone_client_version(),
-                         '3')
-        mock_logger_info.assert_called_once_with("OS_IDENTITY_API_VERSION is "
-                                                 "set in env as '%s'", '3')
-
-    @mock.patch('functest.utils.openstack_utils.get_session')
-    @mock.patch('functest.utils.openstack_utils.keystoneclient.Client')
-    @mock.patch('functest.utils.openstack_utils.get_keystone_client_version',
-                return_value='3')
-    @mock.patch('functest.utils.openstack_utils.os.getenv',
-                return_value='public')
-    def test_get_keystone_client_with_interface(self, mock_os_getenv,
-                                                mock_keystoneclient_version,
-                                                mock_key_client,
-                                                mock_get_session):
-        mock_keystone_obj = mock.Mock()
-        mock_session_obj = mock.Mock()
-        mock_key_client.return_value = mock_keystone_obj
-        mock_get_session.return_value = mock_session_obj
-        self.assertEqual(openstack_utils.get_keystone_client(),
-                         mock_keystone_obj)
-        mock_key_client.assert_called_once_with('3',
-                                                session=mock_session_obj,
-                                                interface='public')
-
-    @mock.patch('functest.utils.openstack_utils.get_session')
-    @mock.patch('functest.utils.openstack_utils.keystoneclient.Client')
-    @mock.patch('functest.utils.openstack_utils.get_keystone_client_version',
-                return_value='3')
-    @mock.patch('functest.utils.openstack_utils.os.getenv',
-                return_value='admin')
-    def test_get_keystone_client_no_interface(self, mock_os_getenv,
-                                              mock_keystoneclient_version,
-                                              mock_key_client,
-                                              mock_get_session):
-        mock_keystone_obj = mock.Mock()
-        mock_session_obj = mock.Mock()
-        mock_key_client.return_value = mock_keystone_obj
-        mock_get_session.return_value = mock_session_obj
-        self.assertEqual(openstack_utils.get_keystone_client(),
-                         mock_keystone_obj)
-        mock_key_client.assert_called_once_with('3',
-                                                session=mock_session_obj,
-                                                interface='admin')
-
-    @mock.patch('functest.utils.openstack_utils.os.getenv',
-                return_value=None)
-    def test_get_nova_client_version_missing_env(self, mock_os_getenv):
-        self.assertEqual(openstack_utils.get_nova_client_version(),
-                         openstack_utils.DEFAULT_API_VERSION)
-
-    @mock.patch('functest.utils.openstack_utils.logger.info')
-    @mock.patch('functest.utils.openstack_utils.os.getenv',
-                return_value='3')
-    def test_get_nova_client_version_default(self, mock_os_getenv,
-                                             mock_logger_info):
-        self.assertEqual(openstack_utils.get_nova_client_version(),
-                         '3')
-        mock_logger_info.assert_called_once_with("OS_COMPUTE_API_VERSION is "
-                                                 "set in env as '%s'", '3')
-
-    def test_get_nova_client(self):
-        mock_nova_obj = mock.Mock()
-        mock_session_obj = mock.Mock()
-        with mock.patch('functest.utils.openstack_utils'
-                        '.get_nova_client_version', return_value='3'), \
-            mock.patch('functest.utils.openstack_utils'
-                       '.novaclient.Client',
-                       return_value=mock_nova_obj) \
-            as mock_nova_client, \
-            mock.patch('functest.utils.openstack_utils.get_session',
-                       return_value=mock_session_obj):
-            self.assertEqual(openstack_utils.get_nova_client(),
-                             mock_nova_obj)
-            mock_nova_client.assert_called_once_with('3',
-                                                     session=mock_session_obj)
-
-    @mock.patch('functest.utils.openstack_utils.os.getenv',
-                return_value=None)
-    def test_get_cinder_client_version_missing_env(self, mock_os_getenv):
-        self.assertEqual(openstack_utils.get_cinder_client_version(),
-                         openstack_utils.DEFAULT_API_VERSION)
-
-    @mock.patch('functest.utils.openstack_utils.logger.info')
-    @mock.patch('functest.utils.openstack_utils.os.getenv',
-                return_value='3')
-    def test_get_cinder_client_version_default(self, mock_os_getenv,
-                                               mock_logger_info):
-        self.assertEqual(openstack_utils.get_cinder_client_version(),
-                         '3')
-        mock_logger_info.assert_called_once_with("OS_VOLUME_API_VERSION is "
-                                                 "set in env as '%s'", '3')
-
-    def test_get_cinder_client(self):
-        mock_cinder_obj = mock.Mock()
-        mock_session_obj = mock.Mock()
-        with mock.patch('functest.utils.openstack_utils'
-                        '.get_cinder_client_version', return_value='3'), \
-            mock.patch('functest.utils.openstack_utils'
-                       '.cinderclient.Client',
-                       return_value=mock_cinder_obj) \
-            as mock_cind_client, \
-            mock.patch('functest.utils.openstack_utils.get_session',
-                       return_value=mock_session_obj):
-            self.assertEqual(openstack_utils.get_cinder_client(),
-                             mock_cinder_obj)
-            mock_cind_client.assert_called_once_with('3',
-                                                     session=mock_session_obj)
-
-    @mock.patch('functest.utils.openstack_utils.os.getenv',
-                return_value=None)
-    def test_get_neutron_client_version_missing_env(self, mock_os_getenv):
-        self.assertEqual(openstack_utils.get_neutron_client_version(),
-                         openstack_utils.DEFAULT_API_VERSION)
-
-    @mock.patch('functest.utils.openstack_utils.logger.info')
-    @mock.patch('functest.utils.openstack_utils.os.getenv',
-                return_value='3')
-    def test_get_neutron_client_version_default(self, mock_os_getenv,
-                                                mock_logger_info):
-        self.assertEqual(openstack_utils.get_neutron_client_version(),
-                         '3')
-        mock_logger_info.assert_called_once_with("OS_NETWORK_API_VERSION is "
-                                                 "set in env as '%s'", '3')
-
-    def test_get_neutron_client(self):
-        mock_neutron_obj = mock.Mock()
-        mock_session_obj = mock.Mock()
-        with mock.patch('functest.utils.openstack_utils'
-                        '.get_neutron_client_version', return_value='3'), \
-            mock.patch('functest.utils.openstack_utils'
-                       '.neutronclient.Client',
-                       return_value=mock_neutron_obj) \
-            as mock_neut_client, \
-            mock.patch('functest.utils.openstack_utils.get_session',
-                       return_value=mock_session_obj):
-            self.assertEqual(openstack_utils.get_neutron_client(),
-                             mock_neutron_obj)
-            mock_neut_client.assert_called_once_with('3',
-                                                     session=mock_session_obj)
-
-    @mock.patch('functest.utils.openstack_utils.os.getenv',
-                return_value=None)
-    def test_get_glance_client_version_missing_env(self, mock_os_getenv):
-        self.assertEqual(openstack_utils.get_glance_client_version(),
-                         openstack_utils.DEFAULT_API_VERSION)
-
-    @mock.patch('functest.utils.openstack_utils.logger.info')
-    @mock.patch('functest.utils.openstack_utils.os.getenv',
-                return_value='3')
-    def test_get_glance_client_version_default(self, mock_os_getenv,
-                                               mock_logger_info):
-        self.assertEqual(openstack_utils.get_glance_client_version(),
-                         '3')
-        mock_logger_info.assert_called_once_with("OS_IMAGE_API_VERSION is "
-                                                 "set in env as '%s'", '3')
-
-    def test_get_glance_client(self):
-        mock_glance_obj = mock.Mock()
-        mock_session_obj = mock.Mock()
-        with mock.patch('functest.utils.openstack_utils'
-                        '.get_glance_client_version', return_value='3'), \
-            mock.patch('functest.utils.openstack_utils'
-                       '.glanceclient.Client',
-                       return_value=mock_glance_obj) \
-            as mock_glan_client, \
-            mock.patch('functest.utils.openstack_utils.get_session',
-                       return_value=mock_session_obj):
-            self.assertEqual(openstack_utils.get_glance_client(),
-                             mock_glance_obj)
-            mock_glan_client.assert_called_once_with('3',
-                                                     session=mock_session_obj)
-
-    @mock.patch('functest.utils.openstack_utils.os.getenv',
-                return_value=None)
-    def test_get_heat_client_version_missing_env(self, mock_os_getenv):
-        self.assertEqual(openstack_utils.get_heat_client_version(),
-                         openstack_utils.DEFAULT_HEAT_API_VERSION)
-
-    @mock.patch('functest.utils.openstack_utils.logger.info')
-    @mock.patch('functest.utils.openstack_utils.os.getenv', return_value='1')
-    def test_get_heat_client_version_default(self, mock_os_getenv,
-                                             mock_logger_info):
-        self.assertEqual(openstack_utils.get_heat_client_version(), '1')
-        mock_logger_info.assert_called_once_with(
-            "OS_ORCHESTRATION_API_VERSION is set in env as '%s'", '1')
-
-    def test_get_heat_client(self):
-        mock_heat_obj = mock.Mock()
-        mock_session_obj = mock.Mock()
-        with mock.patch('functest.utils.openstack_utils'
-                        '.get_heat_client_version', return_value='1'), \
-            mock.patch('functest.utils.openstack_utils'
-                       '.heatclient.Client',
-                       return_value=mock_heat_obj) \
-            as mock_heat_client, \
-            mock.patch('functest.utils.openstack_utils.get_session',
-                       return_value=mock_session_obj):
-            self.assertEqual(openstack_utils.get_heat_client(),
-                             mock_heat_obj)
-            mock_heat_client.assert_called_once_with('1',
-                                                     session=mock_session_obj)
-
-    def test_get_instances_default(self):
-        self.assertEqual(openstack_utils.get_instances(self.nova_client),
-                         [self.instance])
-
-    @mock.patch('functest.utils.openstack_utils.logger.error')
-    def test_get_instances_exception(self, mock_logger_error):
-            self.assertEqual(openstack_utils.
-                             get_instances(Exception),
-                             None)
-            self.assertTrue(mock_logger_error.called)
-
-    def test_get_instance_status_default(self):
-        self.assertEqual(openstack_utils.get_instance_status(self.nova_client,
-                                                             self.instance),
-                         'ok')
-
-    @mock.patch('functest.utils.openstack_utils.logger.error')
-    def test_get_instance_status_exception(self, mock_logger_error):
-            self.assertEqual(openstack_utils.
-                             get_instance_status(Exception,
-                                                 self.instance),
-                             None)
-            self.assertTrue(mock_logger_error.called)
-
-    def test_get_instance_by_name_default(self):
-        self.assertEqual(openstack_utils.
-                         get_instance_by_name(self.nova_client,
-                                              'test_instance'),
-                         self.instance)
-
-    @mock.patch('functest.utils.openstack_utils.logger.error')
-    def test_get_instance_by_name_exception(self, mock_logger_error):
-            self.assertEqual(openstack_utils.
-                             get_instance_by_name(Exception,
-                                                  'test_instance'),
-                             None)
-            self.assertTrue(mock_logger_error.called)
-
-    def test_get_flavor_id_default(self):
-        self.assertEqual(openstack_utils.
-                         get_flavor_id(self.nova_client,
-                                       'test_flavor'),
-                         self.flavor.id)
-
-    def test_get_flavor_id_by_ram_range_default(self):
-        self.assertEqual(openstack_utils.
-                         get_flavor_id_by_ram_range(self.nova_client,
-                                                    1, 3),
-                         self.flavor.id)
-
-    def test_get_aggregates_default(self):
-        self.assertEqual(openstack_utils.
-                         get_aggregates(self.nova_client),
-                         [self.aggregate])
-
-    @mock.patch('functest.utils.openstack_utils.logger.error')
-    def test_get_aggregates_exception(self, mock_logger_error):
-            self.assertEqual(openstack_utils.
-                             get_aggregates(Exception),
-                             None)
-            self.assertTrue(mock_logger_error.called)
-
-    def test_get_aggregate_id_default(self):
-        with mock.patch('functest.utils.openstack_utils.get_aggregates',
-                        return_value=[self.aggregate]):
-            self.assertEqual(openstack_utils.
-                             get_aggregate_id(self.nova_client,
-                                              'test_aggregate'),
-                             'aggregate_id')
-
-    @mock.patch('functest.utils.openstack_utils.logger.error')
-    def test_get_aggregate_id_exception(self, mock_logger_error):
-            self.assertEqual(openstack_utils.
-                             get_aggregate_id(Exception,
-                                              'test_aggregate'),
-                             None)
-            self.assertTrue(mock_logger_error.called)
-
-    def test_get_availability_zone_names_default(self):
-        with mock.patch('functest.utils.openstack_utils'
-                        '.get_availability_zones',
-                        return_value=[self.availability_zone]):
-            self.assertEqual(openstack_utils.
-                             get_availability_zone_names(self.nova_client),
-                             ['test_azone'])
-
-    @mock.patch('functest.utils.openstack_utils.logger.error')
-    def test_get_availability_zone_names_exception(self, mock_logger_error):
-            self.assertEqual(openstack_utils.
-                             get_availability_zone_names(Exception),
-                             None)
-            self.assertTrue(mock_logger_error.called)
-
-    def test_get_availability_zones_default(self):
-            self.assertEqual(openstack_utils.
-                             get_availability_zones(self.nova_client),
-                             [self.availability_zone])
-
-    @mock.patch('functest.utils.openstack_utils.logger.error')
-    def test_get_availability_zones_exception(self, mock_logger_error):
-            self.assertEqual(openstack_utils.
-                             get_availability_zones(Exception),
-                             None)
-            self.assertTrue(mock_logger_error.called)
-
-    def test_get_floating_ips_default(self):
-            self.assertEqual(openstack_utils.
-                             get_floating_ips(self.neutron_client),
-                             [self.floating_ip])
-
-    @mock.patch('functest.utils.openstack_utils.logger.error')
-    def test_get_floating_ips_exception(self, mock_logger_error):
-            self.assertEqual(openstack_utils.
-                             get_floating_ips(Exception),
-                             None)
-            self.assertTrue(mock_logger_error.called)
-
-    def test_get_hypervisors_default(self):
-            self.assertEqual(openstack_utils.
-                             get_hypervisors(self.nova_client),
-                             ['test_hostname'])
-
-    @mock.patch('functest.utils.openstack_utils.logger.error')
-    def test_get_hypervisors_exception(self, mock_logger_error):
-            self.assertEqual(openstack_utils.
-                             get_hypervisors(Exception),
-                             None)
-            self.assertTrue(mock_logger_error.called)
-
-    def test_create_aggregate_default(self):
-            self.assertTrue(openstack_utils.
-                            create_aggregate(self.nova_client,
-                                             'test_aggregate',
-                                             'azone'))
-
-    @mock.patch('functest.utils.openstack_utils.logger.error')
-    def test_create_aggregate_exception(self, mock_logger_error):
-            self.assertEqual(openstack_utils.
-                             create_aggregate(Exception,
-                                              'test_aggregate',
-                                              'azone'),
-                             None)
-            self.assertTrue(mock_logger_error.called)
-
-    def test_add_host_to_aggregate_default(self):
-        with mock.patch('functest.utils.openstack_utils.get_aggregate_id'):
-                self.assertTrue(openstack_utils.
-                                add_host_to_aggregate(self.nova_client,
-                                                      'test_aggregate',
-                                                      'test_hostname'))
-
-    @mock.patch('functest.utils.openstack_utils.logger.error')
-    def test_add_host_to_aggregate_exception(self, mock_logger_error):
-            self.assertEqual(openstack_utils.
-                             add_host_to_aggregate(Exception,
-                                                   'test_aggregate',
-                                                   'test_hostname'),
-                             None)
-            self.assertTrue(mock_logger_error.called)
-
-    def test_create_aggregate_with_host_default(self):
-        with mock.patch('functest.utils.openstack_utils.create_aggregate'), \
-                mock.patch('functest.utils.openstack_utils.'
-                           'add_host_to_aggregate'):
-            self.assertTrue(openstack_utils.
-                            create_aggregate_with_host(self.nova_client,
-                                                       'test_aggregate',
-                                                       'test_azone',
-                                                       'test_hostname'))
-
-    @mock.patch('functest.utils.openstack_utils.logger.error')
-    def test_create_aggregate_with_host_exception(self, mock_logger_error):
-            with mock.patch('functest.utils.openstack_utils.create_aggregate',
-                            side_effect=Exception):
-                self.assertEqual(openstack_utils.
-                                 create_aggregate_with_host(Exception,
-                                                            'test_aggregate',
-                                                            'test_azone',
-                                                            'test_hostname'),
-                                 None)
-                self.assertTrue(mock_logger_error.called)
-
-    def test_create_instance_default(self):
-        with mock.patch('functest.utils.openstack_utils.'
-                        'get_nova_client',
-                        return_value=self.nova_client):
-            self.assertEqual(openstack_utils.
-                             create_instance('test_flavor',
-                                             'image_id',
-                                             'network_id'),
-                             self.instance)
-
-    @mock.patch('functest.utils.openstack_utils.logger.error')
-    def test_create_instance_exception(self, mock_logger_error):
-        with mock.patch('functest.utils.openstack_utils.'
-                        'get_nova_client',
-                        return_value=self.nova_client):
-            self.nova_client.flavors.find.side_effect = Exception
-            self.assertEqual(openstack_utils.
-                             create_instance('test_flavor',
-                                             'image_id',
-                                             'network_id'),
-                             None)
-            self.assertTrue(mock_logger_error)
-
-    def test_create_floating_ip_default(self):
-        with mock.patch('functest.utils.openstack_utils.'
-                        'get_external_net_id',
-                        return_value='external_net_id'):
-            exp_resp = {'fip_addr': 'test_ip', 'fip_id': 'fip_id'}
-            self.assertEqual(openstack_utils.
-                             create_floating_ip(self.neutron_client),
-                             exp_resp)
-
-    @mock.patch('functest.utils.openstack_utils.logger.error')
-    def test_create_floating_ip_exception(self, mock_logger_error):
-        with mock.patch('functest.utils.openstack_utils.'
-                        'get_external_net_id',
-                        return_value='external_net_id'):
-            self.assertEqual(openstack_utils.
-                             create_floating_ip(Exception),
-                             None)
-            self.assertTrue(mock_logger_error)
-
-    def test_add_floating_ip_default(self):
-        with mock.patch('functest.utils.openstack_utils.get_aggregate_id'):
-                self.assertTrue(openstack_utils.
-                                add_floating_ip(self.nova_client,
-                                                'test_serverid',
-                                                'test_floatingip_addr'))
-
-    @mock.patch('functest.utils.openstack_utils.logger.error')
-    def test_add_floating_ip_exception(self, mock_logger_error):
-            self.assertFalse(openstack_utils.
-                             add_floating_ip(Exception,
-                                             'test_serverid',
-                                             'test_floatingip_addr'))
-            self.assertTrue(mock_logger_error.called)
-
-    def test_delete_instance_default(self):
-            self.assertTrue(openstack_utils.
-                            delete_instance(self.nova_client,
-                                            'instance_id'))
-
-    @mock.patch('functest.utils.openstack_utils.logger.error')
-    def test_delete_instance_exception(self, mock_logger_error):
-            self.assertFalse(openstack_utils.
-                             delete_instance(Exception,
-                                             'instance_id'))
-            self.assertTrue(mock_logger_error.called)
-
-    def test_delete_floating_ip_default(self):
-            self.assertTrue(openstack_utils.
-                            delete_floating_ip(self.neutron_client,
-                                               'floating_ip_id'))
-
-    @mock.patch('functest.utils.openstack_utils.logger.error')
-    def test_delete_floating_ip_exception(self, mock_logger_error):
-            self.assertFalse(openstack_utils.
-                             delete_floating_ip(Exception,
-                                                'floating_ip_id'))
-            self.assertTrue(mock_logger_error.called)
-
-    def test_remove_host_from_aggregate_default(self):
-        with mock.patch('functest.utils.openstack_utils.'
-                        'get_aggregate_id'):
-                self.assertTrue(openstack_utils.
-                                remove_host_from_aggregate(self.nova_client,
-                                                           'agg_name',
-                                                           'host_name'))
-
-    @mock.patch('functest.utils.openstack_utils.logger.error')
-    def test_remove_host_from_aggregate_exception(self, mock_logger_error):
-        with mock.patch('functest.utils.openstack_utils.'
-                        'get_aggregate_id', side_effect=Exception):
-            self.assertFalse(openstack_utils.
-                             remove_host_from_aggregate(self.nova_client,
-                                                        'agg_name',
-                                                        'host_name'))
-            self.assertTrue(mock_logger_error.called)
-
-    def test_remove_hosts_from_aggregate_default(self):
-        with mock.patch('functest.utils.openstack_utils.'
-                        'get_aggregate_id'), \
-            mock.patch('functest.utils.openstack_utils.'
-                       'remove_host_from_aggregate',
-                       return_value=True) \
-                as mock_method:
-            openstack_utils.remove_hosts_from_aggregate(self.nova_client,
-                                                        'test_aggregate')
-            mock_method.assert_any_call(self.nova_client,
-                                        'test_aggregate',
-                                        'host_name')
-
-    def test_delete_aggregate_default(self):
-        with mock.patch('functest.utils.openstack_utils.'
-                        'remove_hosts_from_aggregate'):
-                self.assertTrue(openstack_utils.
-                                delete_aggregate(self.nova_client,
-                                                 'agg_name'))
-
-    @mock.patch('functest.utils.openstack_utils.logger.error')
-    def test_delete_aggregate_exception(self, mock_logger_error):
-        with mock.patch('functest.utils.openstack_utils.'
-                        'remove_hosts_from_aggregate', side_effect=Exception):
-            self.assertFalse(openstack_utils.
-                             delete_aggregate(self.nova_client,
-                                              'agg_name'))
-            self.assertTrue(mock_logger_error.called)
-
-    def test_get_network_list_default(self):
-        self.assertEqual(openstack_utils.
-                         get_network_list(self.neutron_client),
-                         self.networks)
-
-    def test_get_network_list_missing_network(self):
-        self.assertEqual(openstack_utils.
-                         get_network_list(self.empty_client),
-                         None)
-
-    def test_get_router_list_default(self):
-        self.assertEqual(openstack_utils.
-                         get_router_list(self.neutron_client),
-                         [self.router])
-
-    def test_get_router_list_missing_router(self):
-        self.assertEqual(openstack_utils.
-                         get_router_list(self.empty_client),
-                         None)
-
-    def test_get_port_list_default(self):
-        self.assertEqual(openstack_utils.
-                         get_port_list(self.neutron_client),
-                         [self.port])
-
-    def test_get_port_list_missing_port(self):
-        self.assertEqual(openstack_utils.
-                         get_port_list(self.empty_client),
-                         None)
-
-    def test_get_network_id_default(self):
-        self.assertEqual(openstack_utils.
-                         get_network_id(self.neutron_client,
-                                        'test_network'),
-                         'network_id')
-
-    def test_get_subnet_id_default(self):
-        self.assertEqual(openstack_utils.
-                         get_subnet_id(self.neutron_client,
-                                       'test_subnet'),
-                         'subnet_id')
-
-    def test_get_router_id_default(self):
-        self.assertEqual(openstack_utils.
-                         get_router_id(self.neutron_client,
-                                       'test_router'),
-                         'router_id')
-
-    def test_get_private_net_default(self):
-        self.assertEqual(openstack_utils.
-                         get_private_net(self.neutron_client),
-                         self.networks[0])
-
-    def test_get_private_net_missing_net(self):
-        self.assertEqual(openstack_utils.
-                         get_private_net(self.empty_client),
-                         None)
-
-    def test_get_external_net_default(self):
-        self.assertEqual(openstack_utils.
-                         get_external_net(self.neutron_client),
-                         'test_network1')
-
-    def test_get_external_net_missing_net(self):
-        self.assertEqual(openstack_utils.
-                         get_external_net(self.empty_client),
-                         None)
-
-    def test_get_external_net_id_default(self):
-        self.assertEqual(openstack_utils.
-                         get_external_net_id(self.neutron_client),
-                         'network_id1')
-
-    def test_get_external_net_id_missing_net(self):
-        self.assertEqual(openstack_utils.
-                         get_external_net_id(self.empty_client),
-                         None)
-
-    def test_check_neutron_net_default(self):
-        self.assertTrue(openstack_utils.
-                        check_neutron_net(self.neutron_client,
-                                          'test_network'))
-
-    def test_check_neutron_net_missing_net(self):
-        self.assertFalse(openstack_utils.
-                         check_neutron_net(self.empty_client,
-                                           'test_network'))
-
-    def test_create_neutron_net_default(self):
-            self.assertEqual(openstack_utils.
-                             create_neutron_net(self.neutron_client,
-                                                'test_network'),
-                             'network_id')
-
-    @mock.patch('functest.utils.openstack_utils.logger.error')
-    def test_create_neutron_net_exception(self, mock_logger_error):
-            self.assertEqual(openstack_utils.
-                             create_neutron_net(Exception,
-                                                'test_network'),
-                             None)
-            self.assertTrue(mock_logger_error.called)
-
-    def test_create_neutron_subnet_default(self):
-            self.assertEqual(openstack_utils.
-                             create_neutron_subnet(self.neutron_client,
-                                                   'test_subnet',
-                                                   'test_cidr',
-                                                   'network_id'),
-                             'subnet_id')
-
-    @mock.patch('functest.utils.openstack_utils.logger.error')
-    def test_create_neutron_subnet_exception(self, mock_logger_error):
-            self.assertEqual(openstack_utils.
-                             create_neutron_subnet(Exception,
-                                                   'test_subnet',
-                                                   'test_cidr',
-                                                   'network_id'),
-                             None)
-            self.assertTrue(mock_logger_error.called)
-
-    def test_create_neutron_router_default(self):
-            self.assertEqual(openstack_utils.
-                             create_neutron_router(self.neutron_client,
-                                                   'test_router'),
-                             'router_id')
-
-    @mock.patch('functest.utils.openstack_utils.logger.error')
-    def test_create_neutron_router_exception(self, mock_logger_error):
-            self.assertEqual(openstack_utils.
-                             create_neutron_router(Exception,
-                                                   'test_router'),
-                             None)
-            self.assertTrue(mock_logger_error.called)
-
-    def test_create_neutron_port_default(self):
-            self.assertEqual(openstack_utils.
-                             create_neutron_port(self.neutron_client,
-                                                 'test_port',
-                                                 'network_id',
-                                                 'test_ip'),
-                             'port_id')
-
-    @mock.patch('functest.utils.openstack_utils.logger.error')
-    def test_create_neutron_port_exception(self, mock_logger_error):
-            self.assertEqual(openstack_utils.
-                             create_neutron_port(Exception,
-                                                 'test_port',
-                                                 'network_id',
-                                                 'test_ip'),
-                             None)
-            self.assertTrue(mock_logger_error.called)
-
-    def test_update_neutron_net_default(self):
-            self.assertTrue(openstack_utils.
-                            update_neutron_net(self.neutron_client,
-                                               'network_id'))
-
-    @mock.patch('functest.utils.openstack_utils.logger.error')
-    def test_update_neutron_net_exception(self, mock_logger_error):
-            self.assertFalse(openstack_utils.
-                             update_neutron_net(Exception,
-                                                'network_id'))
-            self.assertTrue(mock_logger_error.called)
-
-    def test_update_neutron_port_default(self):
-            self.assertEqual(openstack_utils.
-                             update_neutron_port(self.neutron_client,
-                                                 'port_id',
-                                                 'test_owner'),
-                             'port_id')
-
-    @mock.patch('functest.utils.openstack_utils.logger.error')
-    def test_update_neutron_port_exception(self, mock_logger_error):
-            self.assertEqual(openstack_utils.
-                             update_neutron_port(Exception,
-                                                 'port_id',
-                                                 'test_owner'),
-                             None)
-            self.assertTrue(mock_logger_error.called)
-
-    def test_add_interface_router_default(self):
-            self.assertTrue(openstack_utils.
-                            add_interface_router(self.neutron_client,
-                                                 'router_id',
-                                                 'subnet_id'))
-
-    @mock.patch('functest.utils.openstack_utils.logger.error')
-    def test_add_interface_router_exception(self, mock_logger_error):
-            self.assertFalse(openstack_utils.
-                             add_interface_router(Exception,
-                                                  'router_id',
-                                                  'subnet_id'))
-            self.assertTrue(mock_logger_error.called)
-
-    def test_add_gateway_router_default(self):
-        with mock.patch('functest.utils.openstack_utils.'
-                        'get_external_net_id',
-                        return_value='network_id'):
-                self.assertTrue(openstack_utils.
-                                add_gateway_router(self.neutron_client,
-                                                   'router_id'))
-
-    @mock.patch('functest.utils.openstack_utils.logger.error')
-    def test_add_gateway_router_exception(self, mock_logger_error):
-        with mock.patch('functest.utils.openstack_utils.'
-                        'get_external_net_id',
-                        return_value='network_id'):
-                self.assertFalse(openstack_utils.
-                                 add_gateway_router(Exception,
-                                                    'router_id'))
-                self.assertTrue(mock_logger_error.called)
-
-    def test_delete_neutron_net_default(self):
-            self.assertTrue(openstack_utils.
-                            delete_neutron_net(self.neutron_client,
-                                               'network_id'))
-
-    @mock.patch('functest.utils.openstack_utils.logger.error')
-    def test_delete_neutron_net_exception(self, mock_logger_error):
-            self.assertFalse(openstack_utils.
-                             delete_neutron_net(Exception,
-                                                'network_id'))
-            self.assertTrue(mock_logger_error.called)
-
-    def test_delete_neutron_subnet_default(self):
-            self.assertTrue(openstack_utils.
-                            delete_neutron_subnet(self.neutron_client,
-                                                  'subnet_id'))
-
-    @mock.patch('functest.utils.openstack_utils.logger.error')
-    def test_delete_neutron_subnet_exception(self, mock_logger_error):
-            self.assertFalse(openstack_utils.
-                             delete_neutron_subnet(Exception,
-                                                   'subnet_id'))
-            self.assertTrue(mock_logger_error.called)
-
-    def test_delete_neutron_router_default(self):
-            self.assertTrue(openstack_utils.
-                            delete_neutron_router(self.neutron_client,
-                                                  'router_id'))
-
-    @mock.patch('functest.utils.openstack_utils.logger.error')
-    def test_delete_neutron_router_exception(self, mock_logger_error):
-            self.assertFalse(openstack_utils.
-                             delete_neutron_router(Exception,
-                                                   'router_id'))
-            self.assertTrue(mock_logger_error.called)
-
-    def test_delete_neutron_port_default(self):
-            self.assertTrue(openstack_utils.
-                            delete_neutron_port(self.neutron_client,
-                                                'port_id'))
-
-    @mock.patch('functest.utils.openstack_utils.logger.error')
-    def test_delete_neutron_port_exception(self, mock_logger_error):
-            self.assertFalse(openstack_utils.
-                             delete_neutron_port(Exception,
-                                                 'port_id'))
-            self.assertTrue(mock_logger_error.called)
-
-    def test_remove_interface_router_default(self):
-            self.assertTrue(openstack_utils.
-                            remove_interface_router(self.neutron_client,
-                                                    'router_id',
-                                                    'subnet_id'))
-
-    @mock.patch('functest.utils.openstack_utils.logger.error')
-    def test_remove_interface_router_exception(self, mock_logger_error):
-            self.assertFalse(openstack_utils.
-                             remove_interface_router(Exception,
-                                                     'router_id',
-                                                     'subnet_id'))
-            self.assertTrue(mock_logger_error.called)
-
-    def test_remove_gateway_router_default(self):
-            self.assertTrue(openstack_utils.
-                            remove_gateway_router(self.neutron_client,
-                                                  'router_id'))
-
-    @mock.patch('functest.utils.openstack_utils.logger.error')
-    def test_remove_gateway_router_exception(self, mock_logger_error):
-            self.assertFalse(openstack_utils.
-                             remove_gateway_router(Exception,
-                                                   'router_id'))
-            self.assertTrue(mock_logger_error.called)
-
-    def test_get_security_groups_default(self):
-        self.assertEqual(openstack_utils.
-                         get_security_groups(self.neutron_client),
-                         [self.sec_group])
-
-    @mock.patch('functest.utils.openstack_utils.logger.error')
-    def test_get_security_groups_exception(self, mock_logger_error):
-        self.assertEqual(openstack_utils.
-                         get_security_groups(Exception),
-                         None)
-        self.assertTrue(mock_logger_error.called)
-
-    def test_get_security_group_id_default(self):
-        with mock.patch('functest.utils.openstack_utils.'
-                        'get_security_groups',
-                        return_value=[self.sec_group]):
-            self.assertEqual(openstack_utils.
-                             get_security_group_id(self.neutron_client,
-                                                   'test_sec_group'),
-                             'sec_group_id')
-
-    def test_get_security_group_rules_default(self):
-        self.assertEqual(openstack_utils.
-                         get_security_group_rules(self.neutron_client,
-                                                  self.sec_group['id']),
-                         [self.sec_group_rule])
-
-    @mock.patch('functest.utils.openstack_utils.logger.error')
-    def test_get_security_group_rules_exception(self, mock_logger_error):
-        self.assertEqual(openstack_utils.
-                         get_security_group_rules(Exception,
-                                                  'sec_group_id'),
-                         None)
-        self.assertTrue(mock_logger_error.called)
-
-    def test_check_security_group_rules_not_exists(self):
-        self.assertEqual(openstack_utils.
-                         check_security_group_rules(self.neutron_client,
-                                                    'sec_group_id_2',
-                                                    'direction',
-                                                    'protocol',
-                                                    'port_min',
-                                                    'port_max'),
-                         True)
-
-    def test_check_security_group_rules_exists(self):
-        self.assertEqual(openstack_utils.
-                         check_security_group_rules(self.neutron_client,
-                                                    self.sec_group['id'],
-                                                    'direction',
-                                                    'protocol',
-                                                    'port_min',
-                                                    'port_max'),
-                         False)
-
-    @mock.patch('functest.utils.openstack_utils.logger.error')
-    def test_check_security_group_rules_exception(self, mock_logger_error):
-        self.assertEqual(openstack_utils.
-                         check_security_group_rules(Exception,
-                                                    'sec_group_id',
-                                                    'direction',
-                                                    'protocol',
-                                                    'port_max',
-                                                    'port_min'),
-                         None)
-        self.assertTrue(mock_logger_error.called)
-
-    def test_create_security_group_default(self):
-        self.assertEqual(openstack_utils.
-                         create_security_group(self.neutron_client,
-                                               'test_sec_group',
-                                               'sec_group_desc'),
-                         self.sec_group)
-
-    @mock.patch('functest.utils.openstack_utils.logger.error')
-    def test_create_security_group_exception(self, mock_logger_error):
-        self.assertEqual(openstack_utils.
-                         create_security_group(Exception,
-                                               'test_sec_group',
-                                               'sec_group_desc'),
-                         None)
-        self.assertTrue(mock_logger_error.called)
-
-    def test_create_secgroup_rule_default(self):
-        self.assertTrue(openstack_utils.
-                        create_secgroup_rule(self.neutron_client,
-                                             'sg_id',
-                                             'direction',
-                                             'protocol',
-                                             80,
-                                             80))
-        self.assertTrue(openstack_utils.
-                        create_secgroup_rule(self.neutron_client,
-                                             'sg_id',
-                                             'direction',
-                                             'protocol'))
-
-    @mock.patch('functest.utils.openstack_utils.logger.error')
-    def test_create_secgroup_rule_invalid_port_range(self, mock_logger_error):
-        self.assertFalse(openstack_utils.
-                         create_secgroup_rule(self.neutron_client,
-                                              'sg_id',
-                                              'direction',
-                                              'protocol',
-                                              80))
-
-    @mock.patch('functest.utils.openstack_utils.logger.error')
-    def test_create_secgroup_rule_exception(self, mock_logger_error):
-        self.assertFalse(openstack_utils.
-                         create_secgroup_rule(Exception,
-                                              'sg_id',
-                                              'direction',
-                                              'protocol'))
-
-    @mock.patch('functest.utils.openstack_utils.logger.info')
-    def test_create_security_group_full_default(self, mock_logger_info):
-        with mock.patch('functest.utils.openstack_utils.'
-                        'get_security_group_id',
-                        return_value='sg_id'):
-            self.assertEqual(openstack_utils.
-                             create_security_group_full(self.neutron_client,
-                                                        'sg_name',
-                                                        'sg_desc'),
-                             'sg_id')
-            self.assertTrue(mock_logger_info)
-
-    @mock.patch('functest.utils.openstack_utils.logger.info')
-    @mock.patch('functest.utils.openstack_utils.logger.error')
-    def test_create_security_group_full_sec_group_fail(self,
-                                                       mock_logger_error,
-                                                       mock_logger_info):
-        with mock.patch('functest.utils.openstack_utils.'
-                        'get_security_group_id',
-                        return_value=''), \
-            mock.patch('functest.utils.openstack_utils.'
-                       'create_security_group',
-                       return_value=False):
-            self.assertEqual(openstack_utils.
-                             create_security_group_full(self.neutron_client,
-                                                        'sg_name',
-                                                        'sg_desc'),
-                             None)
-            self.assertTrue(mock_logger_error)
-            self.assertTrue(mock_logger_info)
-
-    @mock.patch('functest.utils.openstack_utils.logger.debug')
-    @mock.patch('functest.utils.openstack_utils.logger.info')
-    @mock.patch('functest.utils.openstack_utils.logger.error')
-    def test_create_security_group_full_secgroup_rule_fail(self,
-                                                           mock_logger_error,
-                                                           mock_logger_info,
-                                                           mock_logger_debug):
-        with mock.patch('functest.utils.openstack_utils.'
-                        'get_security_group_id',
-                        return_value=''), \
-            mock.patch('functest.utils.openstack_utils.'
-                       'create_security_group',
-                       return_value={'id': 'sg_id',
-                                     'name': 'sg_name'}), \
-            mock.patch('functest.utils.openstack_utils.'
-                       'create_secgroup_rule',
-                       return_value=False):
-            self.assertEqual(openstack_utils.
-                             create_security_group_full(self.neutron_client,
-                                                        'sg_name',
-                                                        'sg_desc'),
-                             None)
-            self.assertTrue(mock_logger_error)
-            self.assertTrue(mock_logger_info)
-            self.assertTrue(mock_logger_debug)
-
-    def test_add_secgroup_to_instance_default(self):
-        self.assertTrue(openstack_utils.
-                        add_secgroup_to_instance(self.nova_client,
-                                                 'instance_id',
-                                                 'sec_group_id'))
-
-    @mock.patch('functest.utils.openstack_utils.logger.error')
-    def test_add_secgroup_to_instance_exception(self, mock_logger_error):
-        self.assertFalse(openstack_utils.
-                         add_secgroup_to_instance(Exception,
-                                                  'instance_id',
-                                                  'sec_group_id'))
-        self.assertTrue(mock_logger_error.called)
-
-    def test_update_sg_quota_default(self):
-        self.assertTrue(openstack_utils.
-                        update_sg_quota(self.neutron_client,
-                                        'tenant_id',
-                                        'sg_quota',
-                                        'sg_rule_quota'))
-
-    @mock.patch('functest.utils.openstack_utils.logger.error')
-    def test_update_sg_quota_exception(self, mock_logger_error):
-        self.assertFalse(openstack_utils.
-                         update_sg_quota(Exception,
-                                         'tenant_id',
-                                         'sg_quota',
-                                         'sg_rule_quota'))
-        self.assertTrue(mock_logger_error.called)
-
-    def test_delete_security_group_default(self):
-        self.assertTrue(openstack_utils.
-                        delete_security_group(self.neutron_client,
-                                              'sec_group_id'))
-
-    @mock.patch('functest.utils.openstack_utils.logger.error')
-    def test_delete_security_group_exception(self, mock_logger_error):
-        self.assertFalse(openstack_utils.
-                         delete_security_group(Exception,
-                                               'sec_group_id'))
-        self.assertTrue(mock_logger_error.called)
-
-    def test_get_images_default(self):
-        self.assertEqual(openstack_utils.
-                         get_images(self.glance_client),
-                         [self.image])
-
-    @mock.patch('functest.utils.openstack_utils.logger.error')
-    def test_get_images_exception(self, mock_logger_error):
-        self.assertEqual(openstack_utils.
-                         get_images(Exception),
-                         None)
-        self.assertTrue(mock_logger_error.called)
-
-    def test_get_image_id_default(self):
-        self.assertEqual(openstack_utils.
-                         get_image_id(self.glance_client,
-                                      'test_image'),
-                         'image_id')
-
-    # create_glance_image, get_or_create_image
-    @mock.patch('functest.utils.openstack_utils.logger.error')
-    def test_create_glance_image_file_present(self, mock_logger_error):
-        with mock.patch('functest.utils.openstack_utils.'
-                        'os.path.isfile',
-                        return_value=False):
-            self.assertEqual(openstack_utils.
-                             create_glance_image(self.glance_client,
-                                                 'test_image',
-                                                 'file_path'),
-                             None)
-            self.assertTrue(mock_logger_error.called)
-
-    @mock.patch('functest.utils.openstack_utils.logger.info')
-    def test_create_glance_image_already_exist(self, mock_logger_info):
-        with mock.patch('functest.utils.openstack_utils.'
-                        'os.path.isfile',
-                        return_value=True), \
-            mock.patch('functest.utils.openstack_utils.get_image_id',
-                       return_value='image_id'):
-                self.assertEqual(openstack_utils.
-                                 create_glance_image(self.glance_client,
-                                                     'test_image',
-                                                     'file_path'),
-                                 'image_id')
-                self.assertTrue(mock_logger_info.called)
-
-    @mock.patch('functest.utils.openstack_utils.logger.info')
-    def test_create_glance_image_default(self, mock_logger_info):
-        with mock.patch('functest.utils.openstack_utils.'
-                        'os.path.isfile',
-                        return_value=True), \
-            mock.patch('functest.utils.openstack_utils.get_image_id',
-                       return_value=''), \
-            mock.patch('six.moves.builtins.open',
-                       mock.mock_open(read_data='1')) as m:
-                self.assertEqual(openstack_utils.
-                                 create_glance_image(self.glance_client,
-                                                     'test_image',
-                                                     'file_path'),
-                                 'image_id')
-                m.assert_called_once_with('file_path')
-                self.assertTrue(mock_logger_info.called)
-
-    @mock.patch('functest.utils.openstack_utils.logger.error')
-    def test_create_glance_image_exception(self, mock_logger_error):
-        with mock.patch('functest.utils.openstack_utils.'
-                        'os.path.isfile',
-                        return_value=True), \
-            mock.patch('functest.utils.openstack_utils.get_image_id',
-                       side_effect=Exception):
-                self.assertEqual(openstack_utils.
-                                 create_glance_image(self.glance_client,
-                                                     'test_image',
-                                                     'file_path'),
-                                 None)
-                self.assertTrue(mock_logger_error.called)
-
-    def test_delete_glance_image_default(self):
-        self.assertTrue(openstack_utils.
-                        delete_glance_image(self.nova_client,
-                                            'image_id'))
-
-    @mock.patch('functest.utils.openstack_utils.logger.error')
-    def test_delete_glance_image_exception(self, mock_logger_error):
-        self.assertFalse(openstack_utils.
-                         delete_glance_image(Exception,
-                                             'image_id'))
-        self.assertTrue(mock_logger_error.called)
-
-    def test_get_volumes_default(self):
-        self.assertEqual(openstack_utils.
-                         get_volumes(self.cinder_client),
-                         [self.volume])
-
-    @mock.patch('functest.utils.openstack_utils.logger.error')
-    def test_get_volumes_exception(self, mock_logger_error):
-        self.assertEqual(openstack_utils.
-                         get_volumes(Exception),
-                         None)
-        self.assertTrue(mock_logger_error.called)
-
-    def test_update_cinder_quota_default(self):
-        self.assertTrue(openstack_utils.
-                        update_cinder_quota(self.cinder_client,
-                                            'tenant_id',
-                                            'vols_quota',
-                                            'snap_quota',
-                                            'giga_quota'))
-
-    @mock.patch('functest.utils.openstack_utils.logger.error')
-    def test_update_cinder_quota_exception(self, mock_logger_error):
-        self.assertFalse(openstack_utils.
-                         update_cinder_quota(Exception,
-                                             'tenant_id',
-                                             'vols_quota',
-                                             'snap_quota',
-                                             'giga_quota'))
-        self.assertTrue(mock_logger_error.called)
-
-    def test_delete_volume_default(self):
-        self.assertTrue(openstack_utils.
-                        delete_volume(self.cinder_client,
-                                      'volume_id',
-                                      forced=False))
-
-        self.assertTrue(openstack_utils.
-                        delete_volume(self.cinder_client,
-                                      'volume_id',
-                                      forced=True))
-
-    @mock.patch('functest.utils.openstack_utils.logger.error')
-    def test_delete_volume_exception(self, mock_logger_error):
-        self.assertFalse(openstack_utils.
-                         delete_volume(Exception,
-                                       'volume_id',
-                                       forced=True))
-        self.assertTrue(mock_logger_error.called)
-
-    def test_get_tenants_default(self):
-        with mock.patch('functest.utils.openstack_utils.'
-                        'is_keystone_v3', return_value=True):
-            self.assertEqual(openstack_utils.
-                             get_tenants(self.keystone_client),
-                             [self.tenant])
-        with mock.patch('functest.utils.openstack_utils.'
-                        'is_keystone_v3', return_value=False):
-            self.assertEqual(openstack_utils.
-                             get_tenants(self.keystone_client),
-                             [self.tenant])
-
-    @mock.patch('functest.utils.openstack_utils.logger.error')
-    def test_get_tenants_exception(self, mock_logger_error):
-        self.assertEqual(openstack_utils.
-                         get_tenants(Exception),
-                         None)
-        self.assertTrue(mock_logger_error.called)
-
-    def test_get_users_default(self):
-        self.assertEqual(openstack_utils.
-                         get_users(self.keystone_client),
-                         [self.user])
-
-    @mock.patch('functest.utils.openstack_utils.logger.error')
-    def test_get_users_exception(self, mock_logger_error):
-        self.assertEqual(openstack_utils.
-                         get_users(Exception),
-                         None)
-        self.assertTrue(mock_logger_error.called)
-
-    def test_get_tenant_id_default(self):
-        self.assertEqual(openstack_utils.
-                         get_tenant_id(self.keystone_client,
-                                       'test_tenant'),
-                         'tenant_id')
-
-    def test_get_user_id_default(self):
-        self.assertEqual(openstack_utils.
-                         get_user_id(self.keystone_client,
-                                     'test_user'),
-                         'user_id')
-
-    def test_get_role_id_default(self):
-        self.assertEqual(openstack_utils.
-                         get_role_id(self.keystone_client,
-                                     'test_role'),
-                         'role_id')
-
-    def test_get_domain_id_default(self):
-        self.assertEqual(openstack_utils.
-                         get_domain_id(self.keystone_client,
-                                       'test_domain'),
-                         'domain_id')
-
-    def test_create_tenant_default(self):
-        with mock.patch('functest.utils.openstack_utils.'
-                        'is_keystone_v3', return_value=True):
-            os.environ['OS_PROJECT_DOMAIN_NAME'] = 'Default'
-            self.assertEqual(openstack_utils.
-                             create_tenant(self.keystone_client,
-                                           'test_tenant',
-                                           'tenant_desc'),
-                             'tenant_id')
-        with mock.patch('functest.utils.openstack_utils.'
-                        'is_keystone_v3', return_value=False):
-            self.assertEqual(openstack_utils.
-                             create_tenant(self.keystone_client,
-                                           'test_tenant',
-                                           'tenant_desc'),
-                             'tenant_id')
-
-    @mock.patch('functest.utils.openstack_utils.logger.error')
-    def test_create_tenant_exception(self, mock_logger_error):
-        self.assertEqual(openstack_utils.
-                         create_tenant(Exception,
-                                       'test_tenant',
-                                       'tenant_desc'),
-                         None)
-        self.assertTrue(mock_logger_error.called)
-
-    def test_create_user_default(self):
-        with mock.patch('functest.utils.openstack_utils.'
-                        'is_keystone_v3', return_value=True):
-            self.assertEqual(openstack_utils.
-                             create_user(self.keystone_client,
-                                         'test_user',
-                                         'password',
-                                         'email',
-                                         'tenant_id'),
-                             'user_id')
-        with mock.patch('functest.utils.openstack_utils.'
-                        'is_keystone_v3', return_value=False):
-            self.assertEqual(openstack_utils.
-                             create_user(self.keystone_client,
-                                         'test_user',
-                                         'password',
-                                         'email',
-                                         'tenant_id'),
-                             'user_id')
-
-    @mock.patch('functest.utils.openstack_utils.logger.error')
-    def test_create_user_exception(self, mock_logger_error):
-        self.assertEqual(openstack_utils.
-                         create_user(Exception,
-                                     'test_user',
-                                     'password',
-                                     'email',
-                                     'tenant_id'),
-                         None)
-        self.assertTrue(mock_logger_error.called)
-
-    def test_add_role_user_default(self):
-        with mock.patch('functest.utils.openstack_utils.'
-                        'is_keystone_v3', return_value=True):
-            self.assertTrue(openstack_utils.
-                            add_role_user(self.keystone_client,
-                                          'user_id',
-                                          'role_id',
-                                          'tenant_id'))
-
-        with mock.patch('functest.utils.openstack_utils.'
-                        'is_keystone_v3', return_value=False):
-            self.assertTrue(openstack_utils.
-                            add_role_user(self.keystone_client,
-                                          'user_id',
-                                          'role_id',
-                                          'tenant_id'))
-
-    @mock.patch('functest.utils.openstack_utils.logger.error')
-    def test_add_role_user_exception(self, mock_logger_error):
-        self.assertFalse(openstack_utils.
-                         add_role_user(Exception,
-                                       'user_id',
-                                       'role_id',
-                                       'tenant_id'))
-        self.assertTrue(mock_logger_error.called)
-
-    def test_delete_tenant_default(self):
-        with mock.patch('functest.utils.openstack_utils.'
-                        'is_keystone_v3', return_value=True):
-            self.assertTrue(openstack_utils.
-                            delete_tenant(self.keystone_client,
-                                          'tenant_id'))
-
-        with mock.patch('functest.utils.openstack_utils.'
-                        'is_keystone_v3', return_value=False):
-            self.assertTrue(openstack_utils.
-                            delete_tenant(self.keystone_client,
-                                          'tenant_id'))
-
-    @mock.patch('functest.utils.openstack_utils.logger.error')
-    def test_delete_tenant_exception(self, mock_logger_error):
-        self.assertFalse(openstack_utils.
-                         delete_tenant(Exception,
-                                       'tenant_id'))
-        self.assertTrue(mock_logger_error.called)
-
-    def test_delete_user_default(self):
-        self.assertTrue(openstack_utils.
-                        delete_user(self.keystone_client,
-                                    'user_id'))
-
-    @mock.patch('functest.utils.openstack_utils.logger.error')
-    def test_delete_user_exception(self, mock_logger_error):
-        self.assertFalse(openstack_utils.
-                         delete_user(Exception,
-                                     'user_id'))
-        self.assertTrue(mock_logger_error.called)
-
-    def test_get_resource_default(self):
-        with mock.patch('functest.utils.openstack_utils.'
-                        'is_keystone_v3', return_value=True):
-            self.assertEqual(openstack_utils.
-                             get_resource(self.heat_client,
-                                          'stack_id',
-                                          'resource'),
-                             self.resource)
-
-    @mock.patch('functest.utils.openstack_utils.logger.error')
-    def test_get_resource_exception(self, mock_logger_error):
-        self.assertEqual(openstack_utils.
-                         get_resource(Exception,
-                                      'stack_id',
-                                      'resource'),
-                         None)
-        self.assertTrue(mock_logger_error.called)
-
-    def test_get_or_create_user_for_vnf_get(self):
-        with mock.patch('functest.utils.openstack_utils.'
-                        'get_user_id',
-                        return_value='user_id'), \
-            mock.patch('functest.utils.openstack_utils.get_tenant_id',
-                       return_value='tenant_id'):
-            self.assertFalse(openstack_utils.
-                             get_or_create_user_for_vnf(self.keystone_client,
-                                                        'my_vnf'))
-
-    def test_get_or_create_user_for_vnf_create(self):
-        with mock.patch('functest.utils.openstack_utils.'
-                        'get_user_id',
-                        return_value=None), \
-            mock.patch('functest.utils.openstack_utils.get_tenant_id',
-                       return_value='tenant_id'):
-            self.assertTrue(openstack_utils.
-                            get_or_create_user_for_vnf(self.keystone_client,
-                                                       'my_vnf'))
-
-    def test_get_or_create_user_for_vnf_error_get_user_id(self):
-        with mock.patch('functest.utils.openstack_utils.'
-                        'get_user_id',
-                        side_effect=Exception):
-            self.assertRaises(Exception)
-
-    def test_get_or_create_user_for_vnf_error_get_tenant_id(self):
-        with mock.patch('functest.utils.openstack_utils.'
-                        'get_user_id',
-                        return_value='user_id'), \
-            mock.patch('functest.utils.openstack_utils.get_tenant_id',
-                       side_effect='Exception'):
-            self.assertRaises(Exception)
-
-    def test_get_or_create_tenant_for_vnf_get(self):
-        with mock.patch('functest.utils.openstack_utils.'
-                        'get_tenant_id',
-                        return_value='tenant_id'):
-            self.assertFalse(
-                openstack_utils.get_or_create_tenant_for_vnf(
-                    self.keystone_client, 'tenant_name', 'tenant_description'))
-
-    def test_get_or_create_tenant_for_vnf_create(self):
-        with mock.patch('functest.utils.openstack_utils.get_tenant_id',
-                        return_value=None):
-            self.assertTrue(
-                openstack_utils.get_or_create_tenant_for_vnf(
-                    self.keystone_client, 'tenant_name', 'tenant_description'))
-
-    def test_get_or_create_tenant_for_vnf_error_get_tenant_id(self):
-        with mock.patch('functest.utils.openstack_utils.'
-                        'get_tenant_id',
-                        side_effect=Exception):
-            self.assertRaises(Exception)
-
-    def test_download_and_add_image_on_glance_image_creation_failure(self):
-        with mock.patch('functest.utils.openstack_utils.'
-                        'os.makedirs'), \
-            mock.patch('functest.utils.openstack_utils.'
-                       'ft_utils.download_url',
-                       return_value=True), \
-            mock.patch('functest.utils.openstack_utils.'
-                       'create_glance_image',
-                       return_value=''):
-            resp = openstack_utils.download_and_add_image_on_glance(
-                self.glance_client,
-                'image_name',
-                'http://url',
-                'data_dir')
-            self.assertEqual(resp, False)
-
-
-if __name__ == "__main__":
-    logging.disable(logging.CRITICAL)
-    unittest.main(verbosity=2)