← Back to branch summary

~ubuntu-branches/ubuntu/raring/nova/raring-proposed

« back to all changes in this revision

Viewing changes to nova/tests/network/test_api.py

  • Committer: Package Import Robot
  • Author(s): Chuck Short, Adam Gandelman, Chuck Short
  • Date: 2012-11-23 09:04:58 UTC
  • mfrom: (1.1.66)
  • Revision ID: package-import@ubuntu.com-20121123090458-91565o7aev1i1h71
Tags: 2013.1~g1-0ubuntu1
https://launchpad.net/bugs/1073289
https://launchpad.net/bugs/1076442
[ Adam Gandelman ]
* debian/control: Ensure novaclient is upgraded with nova,
  require python-keystoneclient >= 1:2.9.0. (LP: #1073289)
* debian/patches/{ubuntu/*, rbd-security.patch}: Dropped, applied
  upstream.
* debian/control: Add python-testtools to Build-Depends.

[ Chuck Short ]
* New upstream version.
* Refreshed debian/patches/avoid_setuptools_git_dependency.patch.
* debian/rules: FTBFS if missing binaries.
* debian/nova-scheudler.install: Add missing rabbit-queues and
  nova-rpc-zmq-receiver.
* Remove nova-volume since it doesnt exist anymore, transition to cinder-*.
* debian/rules: install apport hook in the right place.
* debian/patches/ubuntu-show-tests.patch: Display test failures.
* debian/control: Add depends on genisoimage
* debian/control: Suggest guestmount.
* debian/control: Suggest websockify. (LP: #1076442)
* debian/nova.conf: Disable nova-volume service.
* debian/control: Depend on xen-system-* rather than the hypervisor.
* debian/control, debian/mans/nova-conductor.8, debian/nova-conductor.init,
  debian/nova-conductor.install, debian/nova-conductor.logrotate
  debian/nova-conductor.manpages, debian/nova-conductor.postrm
  debian/nova-conductor.upstart.in: Add nova-conductor service.
* debian/control: Add python-fixtures as a build deps.

Show diffs side-by-side

added added

removed removed

Lines of Context:
nova/tests/network/test_api.py
17
17
 
18
18
"""Tests for network API"""
19
19
 
 
20
import random
 
21
 
20
22
from nova import context
 
23
from nova import exception
21
24
from nova import network
 
25
from nova.network import rpcapi as network_rpcapi
22
26
from nova.openstack.common import rpc
23
27
from nova import test
24
28
 
25
29
 
 
30
FAKE_UUID = 'a47ae74e-ab08-547f-9eee-ffd23fc46c16'
 
31
 
 
32
 
26
33
class ApiTestCase(test.TestCase):
27
34
    def setUp(self):
28
35
        super(ApiTestCase, self).setUp()
35
42
 
36
43
        new_instance = {'uuid': 'new-uuid'}
37
44
 
38
 
        def fake_rpc_call(context, topic, msg):
 
45
        def fake_rpc_call(context, topic, msg, timeout=None):
39
46
            return orig_instance_uuid
40
47
 
41
48
        self.stubs.Set(rpc, 'call', fake_rpc_call)
78
85
 
79
86
    def test_associate_unassociated_floating_ip(self):
80
87
        self._do_test_associate_floating_ip(None)
 
88
 
 
89
    def _stub_migrate_instance_calls(self, method, multi_host, info):
 
90
        fake_instance_type = {'rxtx_factor': 'fake_factor'}
 
91
        fake_instance = {'uuid': 'fake_uuid',
 
92
                         'instance_type': fake_instance_type,
 
93
                         'project_id': 'fake_project_id'}
 
94
        fake_migration = {'source_compute': 'fake_compute_source',
 
95
                          'dest_compute': 'fake_compute_dest'}
 
96
 
 
97
        def fake_mig_inst_method(*args, **kwargs):
 
98
            info['kwargs'] = kwargs
 
99
 
 
100
        def fake_is_multi_host(*args, **kwargs):
 
101
            return multi_host
 
102
 
 
103
        def fake_get_floaters(*args, **kwargs):
 
104
            return ['fake_float1', 'fake_float2']
 
105
 
 
106
        self.stubs.Set(network_rpcapi.NetworkAPI, method,
 
107
                fake_mig_inst_method)
 
108
        self.stubs.Set(self.network_api, '_is_multi_host',
 
109
                fake_is_multi_host)
 
110
        self.stubs.Set(self.network_api, '_get_floating_ip_addresses',
 
111
                fake_get_floaters)
 
112
 
 
113
        expected = {'instance_uuid': 'fake_uuid',
 
114
                    'source_compute': 'fake_compute_source',
 
115
                    'dest_compute': 'fake_compute_dest',
 
116
                    'rxtx_factor': 'fake_factor',
 
117
                    'project_id': 'fake_project_id',
 
118
                    'floating_addresses': None}
 
119
        if multi_host:
 
120
            expected['floating_addresses'] = ['fake_float1', 'fake_float2']
 
121
        return fake_instance, fake_migration, expected
 
122
 
 
123
    def test_migrate_instance_start_with_multhost(self):
 
124
        info = {'kwargs': {}}
 
125
        arg1, arg2, expected = self._stub_migrate_instance_calls(
 
126
                'migrate_instance_start', True, info)
 
127
        expected['host'] = 'fake_compute_source'
 
128
        self.network_api.migrate_instance_start(self.context, arg1, arg2)
 
129
        self.assertEqual(info['kwargs'], expected)
 
130
 
 
131
    def test_migrate_instance_start_without_multhost(self):
 
132
        info = {'kwargs': {}}
 
133
        arg1, arg2, expected = self._stub_migrate_instance_calls(
 
134
                'migrate_instance_start', False, info)
 
135
        self.network_api.migrate_instance_start(self.context, arg1, arg2)
 
136
        self.assertEqual(info['kwargs'], expected)
 
137
 
 
138
    def test_migrate_instance_finish_with_multhost(self):
 
139
        info = {'kwargs': {}}
 
140
        arg1, arg2, expected = self._stub_migrate_instance_calls(
 
141
                'migrate_instance_finish', True, info)
 
142
        expected['host'] = 'fake_compute_dest'
 
143
        self.network_api.migrate_instance_finish(self.context, arg1, arg2)
 
144
        self.assertEqual(info['kwargs'], expected)
 
145
 
 
146
    def test_migrate_instance_finish_without_multhost(self):
 
147
        info = {'kwargs': {}}
 
148
        arg1, arg2, expected = self._stub_migrate_instance_calls(
 
149
                'migrate_instance_finish', False, info)
 
150
        self.network_api.migrate_instance_finish(self.context, arg1, arg2)
 
151
        self.assertEqual(info['kwargs'], expected)
 
152
 
 
153
    def test_is_multi_host_instance_has_no_fixed_ip(self):
 
154
        def fake_fixed_ip_get_by_instance(ctxt, uuid):
 
155
            raise exception.FixedIpNotFoundForInstance
 
156
        self.stubs.Set(self.network_api.db, 'fixed_ip_get_by_instance',
 
157
                       fake_fixed_ip_get_by_instance)
 
158
        instance = {'uuid': FAKE_UUID}
 
159
        self.assertFalse(self.network_api._is_multi_host(self.context,
 
160
                                                         instance))
 
161
 
 
162
    def test_is_multi_host_network_has_no_project_id(self):
 
163
        is_multi_host = random.choice([True, False])
 
164
        network = {'project_id': None,
 
165
                   'multi_host': is_multi_host, }
 
166
        network_ref = self.network_api.db.network_create_safe(
 
167
                                                 self.context.elevated(),
 
168
                                                 network)
 
169
 
 
170
        def fake_fixed_ip_get_by_instance(ctxt, uuid):
 
171
            fixed_ip = [{'network_id': network_ref['id'],
 
172
                         'instance_uuid': FAKE_UUID, }]
 
173
            return fixed_ip
 
174
 
 
175
        self.stubs.Set(self.network_api.db, 'fixed_ip_get_by_instance',
 
176
                       fake_fixed_ip_get_by_instance)
 
177
 
 
178
        instance = {'uuid': FAKE_UUID}
 
179
        result = self.network_api._is_multi_host(self.context, instance)
 
180
        self.assertEqual(is_multi_host, result)
 
181
 
 
182
    def test_is_multi_host_network_has_project_id(self):
 
183
        is_multi_host = random.choice([True, False])
 
184
        network = {'project_id': self.context.project_id,
 
185
                   'multi_host': is_multi_host, }
 
186
        network_ref = self.network_api.db.network_create_safe(
 
187
                                                 self.context.elevated(),
 
188
                                                 network)
 
189
 
 
190
        def fake_fixed_ip_get_by_instance(ctxt, uuid):
 
191
            fixed_ip = [{'network_id': network_ref['id'],
 
192
                         'instance_uuid': FAKE_UUID, }]
 
193
            return fixed_ip
 
194
 
 
195
        self.stubs.Set(self.network_api.db, 'fixed_ip_get_by_instance',
 
196
                       fake_fixed_ip_get_by_instance)
 
197
 
 
198
        instance = {'uuid': FAKE_UUID}
 
199
        result = self.network_api._is_multi_host(self.context, instance)
 
200
        self.assertEqual(is_multi_host, result)
 
201
 
 
202
    def test_get_backdoor_port(self):
 
203
        backdoor_port = 59697
 
204
 
 
205
        def fake_get_backdoor_port(ctxt):
 
206
            return backdoor_port
 
207
 
 
208
        self.stubs.Set(self.network_api.network_rpcapi, 'get_backdoor_port',
 
209
                       fake_get_backdoor_port)
 
210
 
 
211
        port = self.network_api.get_backdoor_port(self.context)
 
212
        self.assertEqual(port, backdoor_port)