← Back to branch summary

~ubuntu-branches/ubuntu/vivid/ceilometer/vivid

« back to all changes in this revision

Viewing changes to ceilometer/tests/compute/virt/vmware/test_vsphere_operations.py

  • Committer: Package Import Robot
  • Author(s): Chuck Short
  • Date: 2014-03-06 14:44:28 UTC
  • mto: (28.1.1 utopic-proposed) (1.2.1)
  • mto: This revision was merged to the branch mainline in revision 19.
  • Revision ID: package-import@ubuntu.com-20140306144428-rvphsh4igwyulzf0
Tags: upstream-2014.1~b3
Import upstream version 2014.1~b3

Show diffs side-by-side

added added

removed removed

Lines of Context:
ceilometer/tests/compute/virt/vmware/test_vsphere_operations.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
import mock
 
17
from oslo.vmware import api
 
18
 
 
19
from ceilometer.compute.virt.vmware import vsphere_operations
 
20
from ceilometer.openstack.common import test
 
21
 
 
22
 
 
23
class VsphereOperationsTest(test.BaseTestCase):
 
24
 
 
25
    def setUp(self):
 
26
        api_session = api.VMwareAPISession("test_server", "test_user",
 
27
                                           "test_password", 0, None,
 
28
                                           create_session=False)
 
29
        api_session._vim = mock.MagicMock()
 
30
        self._vsphere_ops = vsphere_operations.VsphereOperations(api_session,
 
31
                                                                 1000)
 
32
        super(VsphereOperationsTest, self).setUp()
 
33
 
 
34
    def test_get_vm_moid(self):
 
35
 
 
36
        vm1_moid = "vm-1"
 
37
        vm2_moid = "vm-2"
 
38
        vm1_instance = "0a651a71-142c-4813-aaa6-42e5d5c80d85"
 
39
        vm2_instance = "db1d2533-6bef-4cb2-aef3-920e109f5693"
 
40
 
 
41
        def construct_mock_vm_object(vm_moid, vm_instance):
 
42
            vm_object = mock.MagicMock()
 
43
            vm_object.obj.value = vm_moid
 
44
            vm_object.propSet[0].val = vm_instance
 
45
            return vm_object
 
46
 
 
47
        def retrieve_props_side_effect(pc, specSet, options):
 
48
            # assert inputs
 
49
            self.assertEqual(self._vsphere_ops._max_objects,
 
50
                             options.maxObjects)
 
51
            self.assertEqual(vsphere_operations.VM_INSTANCE_ID_PROPERTY,
 
52
                             specSet[0].pathSet[0])
 
53
 
 
54
            # mock return result
 
55
            vm1 = construct_mock_vm_object(vm1_moid, vm1_instance)
 
56
            vm2 = construct_mock_vm_object(vm2_moid, vm2_instance)
 
57
            result = mock.MagicMock()
 
58
            result.objects.__iter__.return_value = [vm1, vm2]
 
59
            return result
 
60
 
 
61
        vim_mock = self._vsphere_ops._api_session._vim
 
62
        vim_mock.RetrievePropertiesEx.side_effect = retrieve_props_side_effect
 
63
        vim_mock.ContinueRetrievePropertiesEx.return_value = None
 
64
 
 
65
        vm_moid = self._vsphere_ops.get_vm_moid(vm1_instance)
 
66
        self.assertEqual(vm1_moid, vm_moid)
 
67
 
 
68
        vm_moid = self._vsphere_ops.get_vm_moid(vm2_instance)
 
69
        self.assertEqual(vm2_moid, vm_moid)
 
70
 
 
71
    def test_query_vm_property(self):
 
72
 
 
73
        vm_moid = "vm-21"
 
74
        vm_property_name = "runtime.powerState"
 
75
        vm_property_val = "poweredON"
 
76
 
 
77
        def retrieve_props_side_effect(pc, specSet, options):
 
78
            # assert inputs
 
79
            self.assertEqual(vm_moid, specSet[0].obj.value)
 
80
            self.assertEqual(vm_property_name, specSet[0].pathSet[0])
 
81
 
 
82
            # mock return result
 
83
            result = mock.MagicMock()
 
84
            result.objects[0].propSet[0].val = vm_property_val
 
85
            return result
 
86
 
 
87
        vim_mock = self._vsphere_ops._api_session._vim
 
88
        vim_mock.RetrievePropertiesEx.side_effect = retrieve_props_side_effect
 
89
 
 
90
        actual_val = self._vsphere_ops.query_vm_property(vm_moid,
 
91
                                                         vm_property_name)
 
92
        self.assertEqual(vm_property_val, actual_val)
 
93
 
 
94
    def test_get_perf_counter_id(self):
 
95
 
 
96
        def construct_mock_counter_info(group_name, counter_name, rollup_type,
 
97
                                        counter_id):
 
98
            counter_info = mock.MagicMock()
 
99
            counter_info.groupInfo.key = group_name
 
100
            counter_info.nameInfo.key = counter_name
 
101
            counter_info.rollupType = rollup_type
 
102
            counter_info.key = counter_id
 
103
            return counter_info
 
104
 
 
105
        def retrieve_props_side_effect(pc, specSet, options):
 
106
            # assert inputs
 
107
            self.assertEqual(vsphere_operations.PERF_COUNTER_PROPERTY,
 
108
                             specSet[0].pathSet[0])
 
109
 
 
110
            # mock return result
 
111
            counter_info1 = construct_mock_counter_info("a", "b", "c", 1)
 
112
            counter_info2 = construct_mock_counter_info("x", "y", "z", 2)
 
113
            result = mock.MagicMock()
 
114
            result.objects[0].propSet[0].val.PerfCounterInfo.__iter__. \
 
115
                return_value = [counter_info1, counter_info2]
 
116
            return result
 
117
 
 
118
        vim_mock = self._vsphere_ops._api_session._vim
 
119
        vim_mock.RetrievePropertiesEx.side_effect = retrieve_props_side_effect
 
120
 
 
121
        counter_id = self._vsphere_ops.get_perf_counter_id("a:b:c")
 
122
        self.assertEqual(1, counter_id)
 
123
 
 
124
        counter_id = self._vsphere_ops.get_perf_counter_id("x:y:z")
 
125
        self.assertEqual(2, counter_id)
 
126
 
 
127
    def test_query_vm_stats(self):
 
128
 
 
129
        vm_moid = "vm-21"
 
130
        device1 = "device-1"
 
131
        device2 = "device-2"
 
132
        device3 = "device-3"
 
133
        counter_id = 5
 
134
 
 
135
        def construct_mock_metric_series(device_name, stat_values):
 
136
            metric_series = mock.MagicMock()
 
137
            metric_series.value = stat_values
 
138
            metric_series.id.instance = device_name
 
139
            return metric_series
 
140
 
 
141
        def vim_query_perf_side_effect(perf_manager, querySpec):
 
142
            # assert inputs
 
143
            self.assertEqual(vm_moid, querySpec[0].entity.value)
 
144
            self.assertEqual(counter_id, querySpec[0].metricId[0].counterId)
 
145
            self.assertEqual(vsphere_operations.VC_REAL_TIME_SAMPLING_INTERVAL,
 
146
                             querySpec[0].intervalId)
 
147
 
 
148
            # mock return result
 
149
            perf_stats = mock.MagicMock()
 
150
            perf_stats[0].sampleInfo = ["s1", "s2", "s3"]
 
151
            perf_stats[0].value.__iter__.return_value = [
 
152
                construct_mock_metric_series(None, [111, 222, 333]),
 
153
                construct_mock_metric_series(device1, [100, 200, 300]),
 
154
                construct_mock_metric_series(device2, [10, 20, 30]),
 
155
                construct_mock_metric_series(device3, [1, 2, 3])
 
156
            ]
 
157
            return perf_stats
 
158
 
 
159
        vim_mock = self._vsphere_ops._api_session._vim
 
160
        vim_mock.QueryPerf.side_effect = vim_query_perf_side_effect
 
161
        ops = self._vsphere_ops
 
162
 
 
163
        # test aggregate stat
 
164
        stat_val = ops.query_vm_aggregate_stats(vm_moid, counter_id)
 
165
        self.assertEqual(333, stat_val)
 
166
 
 
167
        # test per-device(non-aggregate) stats
 
168
        expected_device_stats = {
 
169
            device1: 300,
 
170
            device2: 30,
 
171
            device3: 3
 
172
        }
 
173
        stats = ops.query_vm_device_stats(vm_moid, counter_id)
 
174
        self.assertEqual(expected_device_stats, stats)