← Back to branch summary

~ubuntu-branches/ubuntu/utopic/ceilometer/utopic-proposed

« back to all changes in this revision

Viewing changes to ceilometer/tests/compute/virt/xenapi/test_inspector.py

  • Committer: Package Import Robot
  • Author(s): Chuck Short
  • Date: 2014-10-16 14:07:11 UTC
  • mfrom: (1.2.1) (28.1.5 utopic-proposed)
  • Revision ID: package-import@ubuntu.com-20141016140711-95mki6bdkivvfr2x
Tags: 2014.2-0ubuntu1
New upstream release. 

Show diffs side-by-side

added added

removed removed

Lines of Context:
ceilometer/tests/compute/virt/xenapi/test_inspector.py
 
1
# Copyright 2014 Intel
 
2
#
 
3
# Author: Ren Qiaowei <qiaowei.ren@intel.com>
 
4
#
 
5
# Licensed under the Apache License, Version 2.0 (the "License"); you may
 
6
# not use this file except in compliance with the License. You may obtain
 
7
# a copy of the License at
 
8
#
 
9
#      http://www.apache.org/licenses/LICENSE-2.0
 
10
#
 
11
# Unless required by applicable law or agreed to in writing, software
 
12
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 
13
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 
14
# License for the specific language governing permissions and limitations
 
15
# under the License.
 
16
"""Tests for xenapi inspector.
 
17
"""
 
18
 
 
19
import mock
 
20
from oslotest import base
 
21
 
 
22
from ceilometer.compute.virt import inspector as virt_inspector
 
23
from ceilometer.compute.virt.xenapi import inspector as xenapi_inspector
 
24
 
 
25
 
 
26
class TestXenapiInspection(base.BaseTestCase):
 
27
 
 
28
    def setUp(self):
 
29
        api_session = mock.Mock()
 
30
        xenapi_inspector.get_api_session = mock.Mock(return_value=api_session)
 
31
        self.inspector = xenapi_inspector.XenapiInspector()
 
32
 
 
33
        super(TestXenapiInspection, self).setUp()
 
34
 
 
35
    def test_inspect_instances(self):
 
36
        vms = {
 
37
            'ref': {
 
38
                'name_label': 'fake_name',
 
39
                'other_config': {'nova_uuid': 'fake_uuid', },
 
40
            }
 
41
        }
 
42
 
 
43
        session = self.inspector.session
 
44
        with mock.patch.object(session, 'xenapi_request',
 
45
                               return_value=vms):
 
46
            inspected_instances = list(self.inspector.inspect_instances())
 
47
            inspected_instance = inspected_instances[0]
 
48
            self.assertEqual('fake_name', inspected_instance.name)
 
49
            self.assertEqual('fake_uuid', inspected_instance.UUID)
 
50
 
 
51
    def test_inspect_cpu_util(self):
 
52
        fake_instance = {'OS-EXT-SRV-ATTR:instance_name': 'fake_instance_name',
 
53
                         'id': 'fake_instance_id'}
 
54
        fake_stat = virt_inspector.CPUUtilStats(util=40)
 
55
 
 
56
        def fake_xenapi_request(method, args):
 
57
            metrics_rec = {
 
58
                'memory_actual': '536870912',
 
59
                'VCPUs_number': '1',
 
60
                'VCPUs_utilisation': {'0': 0.4, }
 
61
            }
 
62
 
 
63
            if method == 'VM.get_by_name_label':
 
64
                return ['vm_ref']
 
65
            elif method == 'VM.get_metrics':
 
66
                return 'metrics_ref'
 
67
            elif method == 'VM_metrics.get_record':
 
68
                return metrics_rec
 
69
            else:
 
70
                return None
 
71
 
 
72
        session = self.inspector.session
 
73
        with mock.patch.object(session, 'xenapi_request',
 
74
                               side_effect=fake_xenapi_request):
 
75
            cpu_util_stat = self.inspector.inspect_cpu_util(fake_instance)
 
76
            self.assertEqual(fake_stat, cpu_util_stat)
 
77
 
 
78
    def test_inspect_memory_usage(self):
 
79
        fake_instance = {'OS-EXT-SRV-ATTR:instance_name': 'fake_instance_name',
 
80
                         'id': 'fake_instance_id'}
 
81
        fake_stat = virt_inspector.MemoryUsageStats(usage=128)
 
82
 
 
83
        def fake_xenapi_request(method, args):
 
84
            metrics_rec = {
 
85
                'memory_actual': '134217728',
 
86
            }
 
87
 
 
88
            if method == 'VM.get_by_name_label':
 
89
                return ['vm_ref']
 
90
            elif method == 'VM.get_metrics':
 
91
                return 'metrics_ref'
 
92
            elif method == 'VM_metrics.get_record':
 
93
                return metrics_rec
 
94
            else:
 
95
                return None
 
96
 
 
97
        session = self.inspector.session
 
98
        with mock.patch.object(session, 'xenapi_request',
 
99
                               side_effect=fake_xenapi_request):
 
100
            memory_stat = self.inspector.inspect_memory_usage(fake_instance)
 
101
            self.assertEqual(fake_stat, memory_stat)
 
102
 
 
103
    def test_inspect_vnic_rates(self):
 
104
        fake_instance = {'OS-EXT-SRV-ATTR:instance_name': 'fake_instance_name',
 
105
                         'id': 'fake_instance_id'}
 
106
 
 
107
        def fake_xenapi_request(method, args):
 
108
            vif_rec = {
 
109
                'metrics': 'vif_metrics_ref',
 
110
                'uuid': 'vif_uuid',
 
111
                'MAC': 'vif_mac',
 
112
            }
 
113
 
 
114
            vif_metrics_rec = {
 
115
                'io_read_kbs': '1',
 
116
                'io_write_kbs': '2',
 
117
            }
 
118
            if method == 'VM.get_by_name_label':
 
119
                return ['vm_ref']
 
120
            elif method == 'VM.get_VIFs':
 
121
                return ['vif_ref']
 
122
            elif method == 'VIF.get_record':
 
123
                return vif_rec
 
124
            elif method == 'VIF.get_metrics':
 
125
                return 'vif_metrics_ref'
 
126
            elif method == 'VIF_metrics.get_record':
 
127
                return vif_metrics_rec
 
128
            else:
 
129
                return None
 
130
 
 
131
        session = self.inspector.session
 
132
        with mock.patch.object(session, 'xenapi_request',
 
133
                               side_effect=fake_xenapi_request):
 
134
            interfaces = list(self.inspector.inspect_vnic_rates(fake_instance))
 
135
 
 
136
            self.assertEqual(1, len(interfaces))
 
137
            vnic0, info0 = interfaces[0]
 
138
            self.assertEqual('vif_uuid', vnic0.name)
 
139
            self.assertEqual('vif_mac', vnic0.mac)
 
140
            self.assertEqual(1024, info0.rx_bytes_rate)
 
141
            self.assertEqual(2048, info0.tx_bytes_rate)
 
142
 
 
143
    def test_inspect_disk_rates(self):
 
144
        fake_instance = {'OS-EXT-SRV-ATTR:instance_name': 'fake_instance_name',
 
145
                         'id': 'fake_instance_id'}
 
146
 
 
147
        def fake_xenapi_request(method, args):
 
148
            vbd_rec = {
 
149
                'device': 'xvdd'
 
150
            }
 
151
 
 
152
            vbd_metrics_rec = {
 
153
                'io_read_kbs': '1',
 
154
                'io_write_kbs': '2'
 
155
            }
 
156
            if method == 'VM.get_by_name_label':
 
157
                return ['vm_ref']
 
158
            elif method == 'VM.get_VBDs':
 
159
                return ['vbd_ref']
 
160
            elif method == 'VBD.get_record':
 
161
                return vbd_rec
 
162
            elif method == 'VBD.get_metrics':
 
163
                return 'vbd_metrics_ref'
 
164
            elif method == 'VBD_metrics.get_record':
 
165
                return vbd_metrics_rec
 
166
            else:
 
167
                return None
 
168
 
 
169
        session = self.inspector.session
 
170
        with mock.patch.object(session, 'xenapi_request',
 
171
                               side_effect=fake_xenapi_request):
 
172
            disks = list(self.inspector.inspect_disk_rates(fake_instance))
 
173
 
 
174
            self.assertEqual(1, len(disks))
 
175
            disk0, info0 = disks[0]
 
176
            self.assertEqual('xvdd', disk0.device)
 
177
            self.assertEqual(1024, info0.read_bytes_rate)
 
178
            self.assertEqual(2048, info0.write_bytes_rate)