← Back to branch summary

~ubuntu-branches/ubuntu/saucy/nova/saucy-proposed

« back to all changes in this revision

Viewing changes to nova/tests/test_vmwareapi.py

  • Committer: Package Import Robot
  • Author(s): Chuck Short, Chuck Short, Adam Gandelman
  • Date: 2013-02-22 09:27:29 UTC
  • mfrom: (1.1.68)
  • Revision ID: package-import@ubuntu.com-20130222092729-nn3gt8rf97uvts77
Tags: 2013.1.g3-0ubuntu1
https://launchpad.net/bugs/1110567
[ Chuck Short ]
* New usptream release. 
* debian/patches/debian/patches/fix-ubuntu-tests.patch: Refreshed.
* debian/nova-baremetal.logrotate: Fix logfile path.
* debian/control, debian/nova-spiceproxy.{install, logrotate, upstart}:
  Add spice html5 proxy support.
* debian/nova-novncproxy.upstart: Start on runlevel [2345]
* debian/rules: Call testr directly since run_tests.sh -N gives weird return
  value when tests pass.
* debian/pyddist-overrides: Add websockify.
* debian/nova-common.postinst: Removed config file conversion, since
  the option is no longer available. (LP: #1110567)
* debian/control: Add python-pyasn1 as a dependency.
* debian/control: Add python-oslo-config as a dependency.
* debian/control: Suggest sysfsutils, sg3-utils, multipath-tools for fibre
  channel support.

[ Adam Gandelman ]
* debian/control: Fix typo (websocikfy -> websockify).

Show diffs side-by-side

added added

removed removed

Lines of Context:
nova/tests/test_vmwareapi.py
1
1
# vim: tabstop=4 shiftwidth=4 softtabstop=4
2
2
 
 
3
# Copyright (c) 2012 VMware, Inc.
3
4
# Copyright (c) 2011 Citrix Systems, Inc.
4
5
# Copyright 2011 OpenStack LLC.
5
6
#
16
17
#    under the License.
17
18
 
18
19
"""
19
 
Test suite for VMWareAPI.
 
20
Test suite for VMwareAPI.
20
21
"""
21
22
 
22
23
from nova.compute import power_state
27
28
from nova import test
28
29
import nova.tests.image.fake
29
30
from nova.tests import matchers
 
31
from nova.tests import utils
30
32
from nova.tests.vmwareapi import db_fakes
31
33
from nova.tests.vmwareapi import stubs
32
34
from nova.virt.vmwareapi import driver
33
35
from nova.virt.vmwareapi import fake as vmwareapi_fake
34
36
 
35
37
 
36
 
class VMWareAPIVMTestCase(test.TestCase):
 
38
class VMwareAPIVMTestCase(test.TestCase):
37
39
    """Unit tests for Vmware API connection calls."""
38
40
 
39
41
    def setUp(self):
40
 
        super(VMWareAPIVMTestCase, self).setUp()
 
42
        super(VMwareAPIVMTestCase, self).setUp()
41
43
        self.context = context.RequestContext('fake', 'fake', is_admin=False)
42
44
        self.flags(vmwareapi_host_ip='test_url',
43
45
                   vmwareapi_host_username='test_username',
44
 
                   vmwareapi_host_password='test_pass')
 
46
                   vmwareapi_host_password='test_pass',
 
47
                   vnc_enabled=False,
 
48
                   use_linked_clone=False)
45
49
        self.user_id = 'fake'
46
50
        self.project_id = 'fake'
47
51
        self.context = context.RequestContext(self.user_id, self.project_id)
48
52
        vmwareapi_fake.reset()
49
53
        db_fakes.stub_out_db_instance_api(self.stubs)
50
54
        stubs.set_stubs(self.stubs)
51
 
        self.conn = driver.VMWareESXDriver(None, False)
 
55
        self.conn = driver.VMwareESXDriver(None, False)
52
56
        # NOTE(vish): none of the network plugging code is actually
53
57
        #             being tested
54
 
        self.network_info = [({'bridge': 'fa0',
55
 
                               'id': 0,
56
 
                               'vlan': None,
57
 
                               'bridge_interface': None,
58
 
                               'injected': True},
59
 
                          {'broadcast': '192.168.0.255',
60
 
                           'dns': ['192.168.0.1'],
61
 
                           'gateway': '192.168.0.1',
62
 
                           'gateway_v6': 'dead:beef::1',
63
 
                           'ip6s': [{'enabled': '1',
64
 
                                     'ip': 'dead:beef::dcad:beff:feef:0',
65
 
                                           'netmask': '64'}],
66
 
                           'ips': [{'enabled': '1',
67
 
                                    'ip': '192.168.0.100',
68
 
                                    'netmask': '255.255.255.0'}],
69
 
                           'label': 'fake',
70
 
                           'mac': 'DE:AD:BE:EF:00:00',
71
 
                           'rxtx_cap': 3})]
 
58
        self.network_info = utils.get_test_network_info(legacy_model=False)
72
59
 
73
60
        self.image = {
74
61
            'id': 'c1c8ce3d-c2e0-4247-890c-ccf5cc1c004c',
78
65
        nova.tests.image.fake.stub_out_image_service(self.stubs)
79
66
 
80
67
    def tearDown(self):
81
 
        super(VMWareAPIVMTestCase, self).tearDown()
 
68
        super(VMwareAPIVMTestCase, self).tearDown()
82
69
        vmwareapi_fake.cleanup()
83
70
        nova.tests.image.fake.FakeImageService_reset()
84
71
 
155
142
        instances = self.conn.list_instances()
156
143
        self.assertEquals(len(instances), 1)
157
144
 
 
145
    def test_list_interfaces(self):
 
146
        self._create_vm()
 
147
        interfaces = self.conn.list_interfaces(1)
 
148
        self.assertEquals(len(interfaces), 1)
 
149
        self.assertEquals(interfaces[0], 4000)
 
150
 
158
151
    def test_spawn(self):
159
152
        self._create_vm()
160
153
        info = self.conn.get_info({'name': 1})
190
183
        info = self.conn.get_info({'name': 1})
191
184
        self._check_vm_info(info, power_state.RUNNING)
192
185
        reboot_type = "SOFT"
193
 
        self.conn.reboot(self.instance, self.network_info, reboot_type)
 
186
        self.conn.reboot(self.context, self.instance, self.network_info,
 
187
                         reboot_type)
194
188
        info = self.conn.get_info({'name': 1})
195
189
        self._check_vm_info(info, power_state.RUNNING)
196
190
 
197
191
    def test_reboot_non_existent(self):
198
192
        self._create_instance_in_the_db()
199
193
        self.assertRaises(exception.InstanceNotFound, self.conn.reboot,
200
 
                          self.instance, self.network_info, 'SOFT')
 
194
                          self.context, self.instance, self.network_info,
 
195
                          'SOFT')
201
196
 
202
197
    def test_reboot_not_poweredon(self):
203
198
        self._create_vm()
205
200
        self._check_vm_info(info, power_state.RUNNING)
206
201
        self.conn.suspend(self.instance)
207
202
        info = self.conn.get_info({'name': 1})
208
 
        self._check_vm_info(info, power_state.PAUSED)
 
203
        self._check_vm_info(info, power_state.SUSPENDED)
209
204
        self.assertRaises(exception.InstanceRebootFailure, self.conn.reboot,
210
 
                          self.instance, self.network_info, 'SOFT')
 
205
                          self.context, self.instance, self.network_info,
 
206
                          'SOFT')
211
207
 
212
208
    def test_suspend(self):
213
209
        self._create_vm()
215
211
        self._check_vm_info(info, power_state.RUNNING)
216
212
        self.conn.suspend(self.instance)
217
213
        info = self.conn.get_info({'name': 1})
218
 
        self._check_vm_info(info, power_state.PAUSED)
 
214
        self._check_vm_info(info, power_state.SUSPENDED)
219
215
 
220
216
    def test_suspend_non_existent(self):
221
217
        self._create_instance_in_the_db()
228
224
        self._check_vm_info(info, power_state.RUNNING)
229
225
        self.conn.suspend(self.instance)
230
226
        info = self.conn.get_info({'name': 1})
231
 
        self._check_vm_info(info, power_state.PAUSED)
 
227
        self._check_vm_info(info, power_state.SUSPENDED)
232
228
        self.conn.resume(self.instance, self.network_info)
233
229
        info = self.conn.get_info({'name': 1})
234
230
        self._check_vm_info(info, power_state.RUNNING)
245
241
        self.assertRaises(exception.InstanceResumeFailure, self.conn.resume,
246
242
                          self.instance, self.network_info)
247
243
 
 
244
    def test_power_on(self):
 
245
        self._create_vm()
 
246
        info = self.conn.get_info({'name': 1})
 
247
        self._check_vm_info(info, power_state.RUNNING)
 
248
        self.conn.power_off(self.instance)
 
249
        info = self.conn.get_info({'name': 1})
 
250
        self._check_vm_info(info, power_state.SHUTDOWN)
 
251
        self.conn.power_on(self.instance)
 
252
        info = self.conn.get_info({'name': 1})
 
253
        self._check_vm_info(info, power_state.RUNNING)
 
254
 
 
255
    def test_power_on_non_existent(self):
 
256
        self._create_instance_in_the_db()
 
257
        self.assertRaises(exception.InstanceNotFound, self.conn.power_on,
 
258
                          self.instance)
 
259
 
 
260
    def test_power_off(self):
 
261
        self._create_vm()
 
262
        info = self.conn.get_info({'name': 1})
 
263
        self._check_vm_info(info, power_state.RUNNING)
 
264
        self.conn.power_off(self.instance)
 
265
        info = self.conn.get_info({'name': 1})
 
266
        self._check_vm_info(info, power_state.SHUTDOWN)
 
267
 
 
268
    def test_power_off_non_existent(self):
 
269
        self._create_instance_in_the_db()
 
270
        self.assertRaises(exception.InstanceNotFound, self.conn.power_off,
 
271
                          self.instance)
 
272
 
 
273
    def test_power_off_suspended(self):
 
274
        self._create_vm()
 
275
        self.conn.suspend(self.instance)
 
276
        info = self.conn.get_info({'name': 1})
 
277
        self._check_vm_info(info, power_state.SUSPENDED)
 
278
        self.assertRaises(exception.InstancePowerOffFailure,
 
279
                          self.conn.power_off, self.instance)
 
280
 
248
281
    def test_get_info(self):
249
282
        self._create_vm()
250
283
        info = self.conn.get_info({'name': 1})
276
309
 
277
310
    def test_get_console_output(self):
278
311
        pass
 
312
 
 
313
 
 
314
class VMwareAPIHostTestCase(test.TestCase):
 
315
    """Unit tests for Vmware API host calls."""
 
316
 
 
317
    def setUp(self):
 
318
        super(VMwareAPIHostTestCase, self).setUp()
 
319
        self.flags(vmwareapi_host_ip='test_url',
 
320
                   vmwareapi_host_username='test_username',
 
321
                   vmwareapi_host_password='test_pass')
 
322
        vmwareapi_fake.reset()
 
323
        stubs.set_stubs(self.stubs)
 
324
        self.conn = driver.VMwareESXDriver(False)
 
325
 
 
326
    def tearDown(self):
 
327
        super(VMwareAPIHostTestCase, self).tearDown()
 
328
        vmwareapi_fake.cleanup()
 
329
 
 
330
    def test_host_state(self):
 
331
        stats = self.conn.get_host_stats()
 
332
        self.assertEquals(stats['vcpus'], 16)
 
333
        self.assertEquals(stats['disk_total'], 1024)
 
334
        self.assertEquals(stats['disk_available'], 500)
 
335
        self.assertEquals(stats['disk_used'], 1024 - 500)
 
336
        self.assertEquals(stats['host_memory_total'], 1024)
 
337
        self.assertEquals(stats['host_memory_free'], 1024 - 500)
 
338
 
 
339
    def _test_host_action(self, method, action, expected=None):
 
340
        result = method('host', action)
 
341
        self.assertEqual(result, expected)
 
342
 
 
343
    def test_host_reboot(self):
 
344
        self._test_host_action(self.conn.host_power_action, 'reboot')
 
345
 
 
346
    def test_host_shutdown(self):
 
347
        self._test_host_action(self.conn.host_power_action, 'shutdown')
 
348
 
 
349
    def test_host_startup(self):
 
350
        self._test_host_action(self.conn.host_power_action, 'startup')
 
351
 
 
352
    def test_host_maintenance_on(self):
 
353
        self._test_host_action(self.conn.host_maintenance_mode, True)
 
354
 
 
355
    def test_host_maintenance_off(self):
 
356
        self._test_host_action(self.conn.host_maintenance_mode, False)