← Back to branch summary

~ubuntu-branches/ubuntu/wily/python-oslo.vmware/wily

« back to all changes in this revision

Viewing changes to tests/test_vim_util.py

  • Committer: Package Import Robot
  • Author(s): Thomas Goirand
  • Date: 2014-03-05 15:29:17 UTC
  • Revision ID: package-import@ubuntu.com-20140305152917-9n6zp4cktcwyr3ul
Tags: upstream-0.2
Import upstream version 0.2

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/test_vim_util.py
 
1
# Copyright (c) 2014 VMware, Inc.
 
2
# All Rights Reserved.
 
3
#
 
4
#    Licensed under the Apache License, Version 2.0 (the "License"); you may
 
5
#    not use this file except in compliance with the License. You may obtain
 
6
#    a copy of the License at
 
7
#
 
8
#         http://www.apache.org/licenses/LICENSE-2.0
 
9
#
 
10
#    Unless required by applicable law or agreed to in writing, software
 
11
#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 
12
#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 
13
#    License for the specific language governing permissions and limitations
 
14
#    under the License.
 
15
 
 
16
"""
 
17
Unit tests for VMware API utility module.
 
18
"""
 
19
 
 
20
import mock
 
21
 
 
22
from oslo.vmware import vim_util
 
23
from tests import base
 
24
 
 
25
 
 
26
class VimUtilTest(base.TestCase):
 
27
    """Test class for utility methods in vim_util."""
 
28
 
 
29
    def test_get_moref(self):
 
30
        moref = vim_util.get_moref("vm-0", "VirtualMachine")
 
31
        self.assertEqual("vm-0", moref.value)
 
32
        self.assertEqual("VirtualMachine", moref._type)
 
33
 
 
34
    def test_build_selection_spec(self):
 
35
        client_factory = mock.Mock()
 
36
        sel_spec = vim_util.build_selection_spec(client_factory, "test")
 
37
        self.assertEqual("test", sel_spec.name)
 
38
 
 
39
    def test_build_traversal_spec(self):
 
40
        client_factory = mock.Mock()
 
41
        sel_spec = mock.Mock()
 
42
        traversal_spec = vim_util.build_traversal_spec(client_factory,
 
43
                                                       'dc_to_hf',
 
44
                                                       'Datacenter',
 
45
                                                       'hostFolder', False,
 
46
                                                       [sel_spec])
 
47
        self.assertEqual("dc_to_hf", traversal_spec.name)
 
48
        self.assertEqual("hostFolder", traversal_spec.path)
 
49
        self.assertEqual([sel_spec], traversal_spec.selectSet)
 
50
        self.assertFalse(traversal_spec.skip)
 
51
        self.assertEqual("Datacenter", traversal_spec.type)
 
52
 
 
53
    @mock.patch.object(vim_util, 'build_selection_spec')
 
54
    def test_build_recursive_traversal_spec(self, build_selection_spec_mock):
 
55
        sel_spec = mock.Mock()
 
56
        rp_to_rp_sel_spec = mock.Mock()
 
57
        rp_to_vm_sel_spec = mock.Mock()
 
58
 
 
59
        def build_sel_spec_side_effect(client_factory, name):
 
60
            if name == 'visitFolders':
 
61
                return sel_spec
 
62
            elif name == 'rp_to_rp':
 
63
                return rp_to_rp_sel_spec
 
64
            elif name == 'rp_to_vm':
 
65
                return rp_to_vm_sel_spec
 
66
            else:
 
67
                return None
 
68
 
 
69
        build_selection_spec_mock.side_effect = build_sel_spec_side_effect
 
70
        traversal_spec_dict = {'dc_to_hf': {'type': 'Datacenter',
 
71
                                            'path': 'hostFolder',
 
72
                                            'skip': False,
 
73
                                            'selectSet': [sel_spec]},
 
74
                               'dc_to_vmf': {'type': 'Datacenter',
 
75
                                             'path': 'vmFolder',
 
76
                                             'skip': False,
 
77
                                             'selectSet': [sel_spec]},
 
78
                               'h_to_vm': {'type': 'HostSystem',
 
79
                                           'path': 'vm',
 
80
                                           'skip': False,
 
81
                                           'selectSet': [sel_spec]},
 
82
                               'cr_to_h': {'type': 'ComputeResource',
 
83
                                           'path': 'host',
 
84
                                           'skip': False,
 
85
                                           'selectSet': []},
 
86
                               'cr_to_ds': {'type': 'ComputeResource',
 
87
                                            'path': 'datastore',
 
88
                                            'skip': False,
 
89
                                            'selectSet': []},
 
90
                               'cr_to_rp': {'type': 'ComputeResource',
 
91
                                            'path': 'resourcePool',
 
92
                                            'skip': False,
 
93
                                            'selectSet': [rp_to_rp_sel_spec,
 
94
                                                          rp_to_vm_sel_spec]},
 
95
                               'cr_to_rp': {'type': 'ComputeResource',
 
96
                                            'path': 'resourcePool',
 
97
                                            'skip': False,
 
98
                                            'selectSet': [rp_to_rp_sel_spec,
 
99
                                                          rp_to_vm_sel_spec]},
 
100
                               'ccr_to_h': {'type': 'ClusterComputeResource',
 
101
                                            'path': 'host',
 
102
                                            'skip': False,
 
103
                                            'selectSet': []},
 
104
                               'ccr_to_ds': {'type': 'ClusterComputeResource',
 
105
                                             'path': 'datastore',
 
106
                                             'skip': False,
 
107
                                             'selectSet': []},
 
108
                               'ccr_to_rp': {'type': 'ClusterComputeResource',
 
109
                                             'path': 'resourcePool',
 
110
                                             'skip': False,
 
111
                                             'selectSet': [rp_to_rp_sel_spec,
 
112
                                                           rp_to_vm_sel_spec]},
 
113
                               'rp_to_rp': {'type': 'ResourcePool',
 
114
                                            'path': 'resourcePool',
 
115
                                            'skip': False,
 
116
                                            'selectSet': [rp_to_rp_sel_spec,
 
117
                                                          rp_to_vm_sel_spec]},
 
118
                               'rp_to_vm': {'type': 'ResourcePool',
 
119
                                            'path': 'vm',
 
120
                                            'skip': False,
 
121
                                            'selectSet': [rp_to_rp_sel_spec,
 
122
                                                          rp_to_vm_sel_spec]},
 
123
                               }
 
124
 
 
125
        client_factory = mock.Mock()
 
126
        client_factory.create.side_effect = lambda ns: mock.Mock()
 
127
        trav_spec = vim_util.build_recursive_traversal_spec(client_factory)
 
128
        self.assertEqual("visitFolders", trav_spec.name)
 
129
        self.assertEqual("childEntity", trav_spec.path)
 
130
        self.assertFalse(trav_spec.skip)
 
131
        self.assertEqual("Folder", trav_spec.type)
 
132
 
 
133
        self.assertEqual(len(traversal_spec_dict) + 1,
 
134
                         len(trav_spec.selectSet))
 
135
        for spec in trav_spec.selectSet:
 
136
            if spec.name not in traversal_spec_dict:
 
137
                self.assertEqual(sel_spec, spec)
 
138
            else:
 
139
                exp_spec = traversal_spec_dict[spec.name]
 
140
                self.assertEqual(exp_spec['type'], spec.type)
 
141
                self.assertEqual(exp_spec['path'], spec.path)
 
142
                self.assertEqual(exp_spec['skip'], spec.skip)
 
143
                self.assertEqual(exp_spec['selectSet'], spec.selectSet)
 
144
 
 
145
    def test_build_property_spec(self):
 
146
        client_factory = mock.Mock()
 
147
        prop_spec = vim_util.build_property_spec(client_factory)
 
148
        self.assertFalse(prop_spec.all)
 
149
        self.assertEqual(["name"], prop_spec.pathSet)
 
150
        self.assertEqual("VirtualMachine", prop_spec.type)
 
151
 
 
152
    def test_build_object_spec(self):
 
153
        client_factory = mock.Mock()
 
154
        root_folder = mock.Mock()
 
155
        specs = [mock.Mock()]
 
156
        obj_spec = vim_util.build_object_spec(client_factory,
 
157
                                              root_folder, specs)
 
158
        self.assertEqual(root_folder, obj_spec.obj)
 
159
        self.assertEqual(specs, obj_spec.selectSet)
 
160
        self.assertFalse(obj_spec.skip)
 
161
 
 
162
    def test_build_property_filter_spec(self):
 
163
        client_factory = mock.Mock()
 
164
        prop_specs = [mock.Mock()]
 
165
        obj_specs = [mock.Mock()]
 
166
        filter_spec = vim_util.build_property_filter_spec(client_factory,
 
167
                                                          prop_specs,
 
168
                                                          obj_specs)
 
169
        self.assertEqual(obj_specs, filter_spec.objectSet)
 
170
        self.assertEqual(prop_specs, filter_spec.propSet)
 
171
 
 
172
    @mock.patch(
 
173
        'oslo.vmware.vim_util.build_recursive_traversal_spec')
 
174
    def test_get_objects(self, build_recursive_traversal_spec):
 
175
        vim = mock.Mock()
 
176
        trav_spec = mock.Mock()
 
177
        build_recursive_traversal_spec.return_value = trav_spec
 
178
        max_objects = 10
 
179
        _type = "VirtualMachine"
 
180
 
 
181
        def vim_RetrievePropertiesEx_side_effect(pc, specSet, options):
 
182
            self.assertTrue(pc is vim.service_content.propertyCollector)
 
183
            self.assertEqual(max_objects, options.maxObjects)
 
184
 
 
185
            self.assertEqual(1, len(specSet))
 
186
            property_filter_spec = specSet[0]
 
187
 
 
188
            propSet = property_filter_spec.propSet
 
189
            self.assertEqual(1, len(propSet))
 
190
            prop_spec = propSet[0]
 
191
            self.assertFalse(prop_spec.all)
 
192
            self.assertEqual(["name"], prop_spec.pathSet)
 
193
            self.assertEqual(_type, prop_spec.type)
 
194
 
 
195
            objSet = property_filter_spec.objectSet
 
196
            self.assertEqual(1, len(objSet))
 
197
            obj_spec = objSet[0]
 
198
            self.assertTrue(obj_spec.obj is vim.service_content.rootFolder)
 
199
            self.assertEqual([trav_spec], obj_spec.selectSet)
 
200
            self.assertFalse(obj_spec.skip)
 
201
 
 
202
        vim.RetrievePropertiesEx.side_effect = \
 
203
            vim_RetrievePropertiesEx_side_effect
 
204
        vim_util.get_objects(vim, _type, max_objects)
 
205
        self.assertEqual(1, vim.RetrievePropertiesEx.call_count)
 
206
 
 
207
    def test_get_object_properties_with_empty_moref(self):
 
208
        vim = mock.Mock()
 
209
        ret = vim_util.get_object_properties(vim, None, None)
 
210
        self.assertEqual(None, ret)
 
211
 
 
212
    @mock.patch('oslo.vmware.vim_util.cancel_retrieval')
 
213
    def test_get_object_properties(self, cancel_retrieval):
 
214
        vim = mock.Mock()
 
215
        moref = mock.Mock()
 
216
        moref._type = "VirtualMachine"
 
217
        retrieve_result = mock.Mock()
 
218
 
 
219
        def vim_RetrievePropertiesEx_side_effect(pc, specSet, options):
 
220
            self.assertTrue(pc is vim.service_content.propertyCollector)
 
221
            self.assertEqual(1, options.maxObjects)
 
222
 
 
223
            self.assertEqual(1, len(specSet))
 
224
            property_filter_spec = specSet[0]
 
225
 
 
226
            propSet = property_filter_spec.propSet
 
227
            self.assertEqual(1, len(propSet))
 
228
            prop_spec = propSet[0]
 
229
            self.assertTrue(prop_spec.all)
 
230
            self.assertEqual(['name'], prop_spec.pathSet)
 
231
            self.assertEqual(moref._type, prop_spec.type)
 
232
 
 
233
            objSet = property_filter_spec.objectSet
 
234
            self.assertEqual(1, len(objSet))
 
235
            obj_spec = objSet[0]
 
236
            self.assertEqual(moref, obj_spec.obj)
 
237
            self.assertEqual([], obj_spec.selectSet)
 
238
            self.assertFalse(obj_spec.skip)
 
239
 
 
240
            return retrieve_result
 
241
 
 
242
        vim.RetrievePropertiesEx.side_effect = \
 
243
            vim_RetrievePropertiesEx_side_effect
 
244
 
 
245
        res = vim_util.get_object_properties(vim, moref, None)
 
246
        self.assertEqual(1, vim.RetrievePropertiesEx.call_count)
 
247
        self.assertTrue(res is retrieve_result.objects)
 
248
        cancel_retrieval.assert_called_once_with(vim, retrieve_result)
 
249
 
 
250
    def test_get_token(self):
 
251
        retrieve_result = object()
 
252
        self.assertFalse(vim_util._get_token(retrieve_result))
 
253
 
 
254
    @mock.patch('oslo.vmware.vim_util._get_token')
 
255
    def test_cancel_retrieval(self, get_token):
 
256
        token = mock.Mock()
 
257
        get_token.return_value = token
 
258
        vim = mock.Mock()
 
259
        retrieve_result = mock.Mock()
 
260
        vim_util.cancel_retrieval(vim, retrieve_result)
 
261
        get_token.assert_called_once_with(retrieve_result)
 
262
        vim.CancelRetrievePropertiesEx.assert_called_once_with(
 
263
            vim.service_content.propertyCollector, token=token)
 
264
 
 
265
    @mock.patch('oslo.vmware.vim_util._get_token')
 
266
    def test_continue_retrieval(self, get_token):
 
267
        token = mock.Mock()
 
268
        get_token.return_value = token
 
269
        vim = mock.Mock()
 
270
        retrieve_result = mock.Mock()
 
271
        vim_util.continue_retrieval(vim, retrieve_result)
 
272
        get_token.assert_called_once_with(retrieve_result)
 
273
        vim.ContinueRetrievePropertiesEx.assert_called_once_with(
 
274
            vim.service_content.propertyCollector, token=token)
 
275
 
 
276
    @mock.patch('oslo.vmware.vim_util.get_object_properties')
 
277
    def test_get_object_property(self, get_object_properties):
 
278
        prop = mock.Mock()
 
279
        prop.val = "ubuntu-12.04"
 
280
        properties = mock.Mock()
 
281
        properties.propSet = [prop]
 
282
        properties_list = [properties]
 
283
        get_object_properties.return_value = properties_list
 
284
        vim = mock.Mock()
 
285
        moref = mock.Mock()
 
286
        property_name = 'name'
 
287
        val = vim_util.get_object_property(vim, moref, property_name)
 
288
        self.assertEqual(prop.val, val)
 
289
        get_object_properties.assert_called_once_with(
 
290
            vim, moref, [property_name])