aboutsummaryrefslogtreecommitdiffstats
path: root/functest/tests/unit/vnf/ims/test_cloudify_ims.py
blob: f0483c69fb5078639e217084b7347f9b3e208697 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
#!/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

import logging
import unittest

import mock

from functest.core import vnf
from functest.opnfv_tests.vnf.ims import cloudify_ims

from snaps.openstack.os_credentials import OSCreds


class CloudifyImsTesting(unittest.TestCase):

    def setUp(self):

        self.tenant = 'cloudify_ims'
        self.creds = {'username': 'user',
                      'password': 'pwd'}
        self.orchestrator = {'name': 'cloudify',
                             'version': '4.0',
                             'object': 'foo',
                             'requirements': {'flavor': {'name': 'm1.medium',
                                                         'ram_min': 4096},
                                              'os_image': 'manager_4.0'}}

        self.vnf = {'name': 'clearwater',
                    'descriptor': {'version': '108',
                                   'file_name': 'openstack-blueprint.yaml',
                                   'name': 'clearwater-opnfv',
                                   'url': 'https://foo',
                                   'requirements': {'flavor':
                                                    {'name': 'm1.medium',
                                                     'ram_min': 2048}}}}

        with mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.'
                        'os.makedirs'), \
            mock.patch('functest.opnfv_tests.vnf.ims.cloudify_ims.'
                       'get_config', return_value={
                           'tenant_images': 'foo',
                           'orchestrator': self.orchestrator,
                           'vnf': self.vnf,
                           'vnf_test_suite': '',
                           'version': 'whatever'}):

            self.ims_vnf = cloudify_ims.CloudifyIms()

        self.images = {'image1': 'url1',
                       'image2': 'url2'}
        self.details = {'orchestrator': {'status': 'PASS', 'duration': 120},
                        'vnf': {},
                        'test_vnf':  {}}

    @mock.patch('functest.core.vnf.os_utils.get_keystone_client',
                return_value='test')
    @mock.patch('functest.core.vnf.os_utils.get_or_create_tenant_for_vnf',
                return_value=True)
    @mock.patch('functest.core.vnf.os_utils.get_or_create_user_for_vnf',
                return_value=True)
    @mock.patch('functest.core.vnf.os_utils.get_credentials',
                return_value={'auth_url': 'test/v1'})
    @mock.patch('snaps.openstack.create_image.OpenStackImage.create')
    def test_prepare_default(self, *args):
        self.assertIsNone(self.ims_vnf.prepare())
        args[4].assert_called_once_with()

    @mock.patch('functest.core.vnf.os_utils.get_keystone_client',
                return_value='test')
    @mock.patch('functest.core.vnf.os_utils.get_or_create_tenant_for_vnf',
                return_value=True)
    @mock.patch('functest.core.vnf.os_utils.get_or_create_user_for_vnf',
                return_value=True)
    @mock.patch('functest.core.vnf.os_utils.get_credentials',
                return_value={'auth_url': 'test/no_v'})
    @mock.patch('snaps.openstack.create_image.OpenStackImage.create')
    def test_prepare_bad_auth_url(self, *args):
        with self.assertRaises(Exception):
            self.ims_vnf.image_creator(
                OSCreds(username='user', password='pass', auth_url='url',
                        project_name='project', identity_api_version=3),
                mock.Mock())
            args[0].assert_not_called()

    def test_prepare_missing_param(self):
        with self.assertRaises(vnf.VnfPreparationException):
            self.ims_vnf.prepare()

    @mock.patch('functest.core.vnf.os_utils.get_keystone_client',
                side_effect=Exception)
    def test_prepare_keystone_exception(self, *args):
        with self.assertRaises(vnf.VnfPreparationException):
            self.ims_vnf.prepare()
        args[0].assert_called_once_with()

    @mock.patch('functest.core.vnf.os_utils.get_keystone_client',
                return_value='test')
    @mock.patch('functest.core.vnf.os_utils.get_or_create_tenant_for_vnf',
                side_effect=Exception)
    def test_prepare_tenant_exception(self, *args):
        with self.assertRaises(vnf.VnfPreparationException):
            self.ims_vnf.prepare()
        args[1].assert_called_once_with()

    @mock.patch('functest.core.vnf.os_utils.get_keystone_client',
                return_value='test')
    @mock.patch('functest.core.vnf.os_utils.get_or_create_tenant_for_vnf',
                return_value=True)
    @mock.patch('functest.core.vnf.os_utils.get_or_create_user_for_vnf',
                side_effect=Exception)
    def test_prepare_user_exception(self, *args):
        with self.assertRaises(vnf.VnfPreparationException):
            self.ims_vnf.prepare()
        args[2].assert_called_once_with()

    @mock.patch('functest.core.vnf.os_utils.get_keystone_client',
                return_value='test')
    @mock.patch('functest.core.vnf.os_utils.get_or_create_tenant_for_vnf',
                return_value=True)
    @mock.patch('functest.core.vnf.os_utils.get_or_create_user_for_vnf',
                return_value=True)
    @mock.patch('functest.core.vnf.os_utils.get_credentials',
                side_effect=Exception)
    def test_prepare_credentials_exception(self, *args):
        with self.assertRaises(vnf.VnfPreparationException):
            self.ims_vnf.prepare()
        args[0].assert_called_once_with()

    # @mock.patch('snaps.openstack.create_keypairs.OpenStackKeypair',
    #             side_effect=Exception)
    # def test_deploy_orchestrator_keypair_exception(self, *args):
    #    with self.assertRaises(vnf.OrchestratorDeploymentException):
    #        self.ims_vnf.deploy_orchestrator()

    #   def test_deploy_orchestrator_network_creation_fail(self):
    #   def test_deploy_orchestrator_floatting_ip_creation_fail(self):
    #   def test_deploy_orchestrator_flavor_fail(self):
    #   def test_deploy_orchestrator_get_image_id_fail(self):
    #   def test_deploy_orchestrator_create_instance_fail(self):
    #   def test_deploy_orchestrator_secgroup_fail(self):
    #   def test_deploy_orchestrator_add_floating_ip_fail(self):
    #   def test_deploy_orchestrator_get_endpoint_fail(self):
    #   def test_deploy_orchestrator_initiate CloudifyClient_fail(self):
    #   def test_deploy_orchestrator_get_status_fail(self):
    #

    #   def test_deploy_vnf(self):
    #   def test_deploy_vnf_publish_fail(self):
    #   def test_deploy_vnf_get_flavor_fail(self):
    #   def test_deploy_vnf_get_external_net_fail(self):
    #   def test_deploy_vnf_deployment_create_fail(self):
    #   def test_deploy_vnf_start_fail(self):
    #
    #   def test_test_vnf(self):
    #   def test_test_vnf_deployment_get_fail(self):
    #   def test_test_vnf_run_live_test_fail(self):
    #
    #   def test_clean(self):
    #   def test_clean_execution_start_fail(self):
    #   def test_clean_deployment_delete_fail(self):
    #   def test_clean_blueprint_delete_fail(self):


if __name__ == "__main__":
    logging.disable(logging.CRITICAL)
    unittest.main(verbosity=2)