← Back to branch summary

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

« back to all changes in this revision

Viewing changes to nova/tests/test_network_info.py

  • Committer: Package Import Robot
  • Author(s): Chuck Short
  • Date: 2012-05-24 13:12:53 UTC
  • mfrom: (1.1.55)
  • Revision ID: package-import@ubuntu.com-20120524131253-ommql08fg1en06ut
Tags: 2012.2~f1-0ubuntu1
https://launchpad.net/bugs/907197
* New upstream release.
* Prepare for quantal:
  - Dropped debian/patches/upstream/0006-Use-project_id-in-ec2.cloud._format_image.patch
  - Dropped debian/patches/upstream/0005-Populate-image-properties-with-project_id-again.patch
  - Dropped debian/patches/upstream/0004-Fixed-bug-962840-added-a-test-case.patch
  - Dropped debian/patches/upstream/0003-Allow-unprivileged-RADOS-users-to-access-rbd-volumes.patch
  - Dropped debian/patches/upstream/0002-Stop-libvirt-test-from-deleting-instances-dir.patch
  - Dropped debian/patches/upstream/0001-fix-bug-where-nova-ignores-glance-host-in-imageref.patch 
  - Dropped debian/patches/0001-fix-useexisting-deprecation-warnings.patch
* debian/control: Add python-keystone as a dependency. (LP: #907197)
* debian/patches/kombu_tests_timeout.patch: Refreshed.
* debian/nova.conf, debian/nova-common.postinst: Convert to new ini
  file configuration
* debian/patches/nova-manage_flagfile_location.patch: Refreshed

Show diffs side-by-side

added added

removed removed

Lines of Context:
nova/tests/test_network_info.py
1
 
# vim: tabstop=4 shiftwidth=4 softtabstop=4
2
 
 
3
 
# Copyright 2011 OpenStack LLC.
4
 
# All Rights Reserved.
5
 
#
6
 
#    Licensed under the Apache License, Version 2.0 (the "License"); you may
7
 
#    not use this file except in compliance with the License. You may obtain
8
 
#    a copy of the License at
9
 
#
10
 
#         http://www.apache.org/licenses/LICENSE-2.0
11
 
#
12
 
#    Unless required by applicable law or agreed to in writing, software
13
 
#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
14
 
#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
15
 
#    License for the specific language governing permissions and limitations
16
 
#    under the License.
17
 
 
18
 
from nova import exception
19
 
from nova import log as logging
20
 
from nova.network import model
21
 
from nova import test
22
 
from nova.tests import fake_network_cache_model
23
 
 
24
 
LOG = logging.getLogger(__name__)
25
 
 
26
 
 
27
 
class RouteTests(test.TestCase):
28
 
    def test_create_route_with_attrs(self):
29
 
        route = fake_network_cache_model.new_route()
30
 
        ip = fake_network_cache_model.new_ip(dict(address='192.168.1.1'))
31
 
        self.assertEqual(route['cidr'], '0.0.0.0/24')
32
 
        self.assertEqual(route['gateway']['address'], '192.168.1.1')
33
 
        self.assertEqual(route['interface'], 'eth0')
34
 
 
35
 
    def test_routes_equal(self):
36
 
        route1 = fake_network_cache_model.new_route()
37
 
        route2 = fake_network_cache_model.new_route()
38
 
        self.assertEqual(route1, route2)
39
 
 
40
 
    def test_routes_not_equal(self):
41
 
        route1 = fake_network_cache_model.new_route()
42
 
        route2 = fake_network_cache_model.new_route(dict(cidr='1.1.1.1/24'))
43
 
        self.assertNotEqual(route1, route2)
44
 
 
45
 
    def test_hydrate(self):
46
 
        route = model.Route.hydrate(
47
 
                {'gateway': fake_network_cache_model.new_ip(
48
 
                                dict(address='192.168.1.1'))})
49
 
        self.assertEqual(route['cidr'], None)
50
 
        self.assertEqual(route['gateway']['address'], '192.168.1.1')
51
 
        self.assertEqual(route['interface'], None)
52
 
 
53
 
 
54
 
class FixedIPTests(test.TestCase):
55
 
    def test_createnew_fixed_ip_with_attrs(self):
56
 
        fixed_ip = model.FixedIP(address='192.168.1.100')
57
 
        self.assertEqual(fixed_ip['address'], '192.168.1.100')
58
 
        self.assertEqual(fixed_ip['floating_ips'], [])
59
 
        self.assertEqual(fixed_ip['type'], 'fixed')
60
 
        self.assertEqual(fixed_ip['version'], 4)
61
 
 
62
 
    def test_create_fixed_ipv6(self):
63
 
        fixed_ip = model.FixedIP(address='::1')
64
 
        self.assertEqual(fixed_ip['address'], '::1')
65
 
        self.assertEqual(fixed_ip['floating_ips'], [])
66
 
        self.assertEqual(fixed_ip['type'], 'fixed')
67
 
        self.assertEqual(fixed_ip['version'], 6)
68
 
 
69
 
    def test_create_fixed_bad_ip_fails(self):
70
 
        self.assertRaises(exception.InvalidIpAddressError,
71
 
                          model.FixedIP,
72
 
                          address='picklespicklespickles')
73
 
 
74
 
    def test_equate_two_fixed_ips(self):
75
 
        fixed_ip = model.FixedIP(address='::1')
76
 
        fixed_ip2 = model.FixedIP(address='::1')
77
 
        self.assertEqual(fixed_ip, fixed_ip2)
78
 
 
79
 
    def test_equate_two_dissimilar_fixed_ips_fails(self):
80
 
        fixed_ip = model.FixedIP(address='::1')
81
 
        fixed_ip2 = model.FixedIP(address='::2')
82
 
        self.assertNotEqual(fixed_ip, fixed_ip2)
83
 
 
84
 
    def test_hydrate(self):
85
 
        fixed_ip = model.FixedIP.hydrate({})
86
 
        self.assertEqual(fixed_ip['floating_ips'], [])
87
 
        self.assertEqual(fixed_ip['address'], None)
88
 
        self.assertEqual(fixed_ip['type'], 'fixed')
89
 
        self.assertEqual(fixed_ip['version'], None)
90
 
 
91
 
    def test_add_floating_ip(self):
92
 
        fixed_ip = model.FixedIP(address='192.168.1.100')
93
 
        fixed_ip.add_floating_ip('192.168.1.101')
94
 
        self.assertEqual(fixed_ip['floating_ips'], ['192.168.1.101'])
95
 
 
96
 
    def test_add_floating_ip_repeatedly_only_one_instance(self):
97
 
        fixed_ip = model.FixedIP(address='192.168.1.100')
98
 
        for i in xrange(10):
99
 
            fixed_ip.add_floating_ip('192.168.1.101')
100
 
        self.assertEqual(fixed_ip['floating_ips'], ['192.168.1.101'])
101
 
 
102
 
 
103
 
class SubnetTests(test.TestCase):
104
 
    def test_create_subnet_with_attrs(self):
105
 
        subnet = fake_network_cache_model.new_subnet()
106
 
 
107
 
        route1 = fake_network_cache_model.new_route()
108
 
 
109
 
        self.assertEqual(subnet['cidr'], '10.10.0.0/24')
110
 
        self.assertEqual(subnet['dns'],
111
 
                [fake_network_cache_model.new_ip(dict(address='1.2.3.4')),
112
 
                 fake_network_cache_model.new_ip(dict(address='2.3.4.5'))])
113
 
        self.assertEqual(subnet['gateway']['address'], '10.10.0.1')
114
 
        self.assertEqual(subnet['ips'],
115
 
                [fake_network_cache_model.new_ip(
116
 
                        dict(address='10.10.0.2')),
117
 
                 fake_network_cache_model.new_ip(
118
 
                            dict(address='10.10.0.3'))])
119
 
        self.assertEqual(subnet['routes'], [route1])
120
 
        self.assertEqual(subnet['version'], 4)
121
 
 
122
 
    def test_add_route(self):
123
 
        subnet = fake_network_cache_model.new_subnet()
124
 
        route1 = fake_network_cache_model.new_route()
125
 
        route2 = fake_network_cache_model.new_route({'cidr': '1.1.1.1/24'})
126
 
        subnet.add_route(route2)
127
 
        self.assertEqual(subnet['routes'], [route1, route2])
128
 
 
129
 
    def test_add_route_a_lot(self):
130
 
        subnet = fake_network_cache_model.new_subnet()
131
 
        route1 = fake_network_cache_model.new_route()
132
 
        route2 = fake_network_cache_model.new_route({'cidr': '1.1.1.1/24'})
133
 
        for i in xrange(10):
134
 
            subnet.add_route(route2)
135
 
        self.assertEqual(subnet['routes'], [route1, route2])
136
 
 
137
 
    def test_add_dns(self):
138
 
        subnet = fake_network_cache_model.new_subnet()
139
 
        dns = fake_network_cache_model.new_ip(dict(address='9.9.9.9'))
140
 
        subnet.add_dns(dns)
141
 
        self.assertEqual(subnet['dns'],
142
 
                [fake_network_cache_model.new_ip(dict(address='1.2.3.4')),
143
 
                 fake_network_cache_model.new_ip(dict(address='2.3.4.5')),
144
 
                 fake_network_cache_model.new_ip(dict(address='9.9.9.9'))])
145
 
 
146
 
    def test_add_dns_a_lot(self):
147
 
        subnet = fake_network_cache_model.new_subnet()
148
 
        for i in xrange(10):
149
 
            subnet.add_dns(fake_network_cache_model.new_ip(
150
 
                    dict(address='9.9.9.9')))
151
 
        self.assertEqual(subnet['dns'],
152
 
                [fake_network_cache_model.new_ip(dict(address='1.2.3.4')),
153
 
                 fake_network_cache_model.new_ip(dict(address='2.3.4.5')),
154
 
                 fake_network_cache_model.new_ip(dict(address='9.9.9.9'))])
155
 
 
156
 
    def test_add_ip(self):
157
 
        subnet = fake_network_cache_model.new_subnet()
158
 
        subnet.add_ip(fake_network_cache_model.new_ip(
159
 
                dict(address='192.168.1.102')))
160
 
        self.assertEqual(subnet['ips'],
161
 
                [fake_network_cache_model.new_ip(
162
 
                        dict(address='10.10.0.2')),
163
 
                 fake_network_cache_model.new_ip(
164
 
                        dict(address='10.10.0.3')),
165
 
                 fake_network_cache_model.new_ip(
166
 
                        dict(address='192.168.1.102'))])
167
 
 
168
 
    def test_add_ip_a_lot(self):
169
 
        subnet = fake_network_cache_model.new_subnet()
170
 
        for i in xrange(10):
171
 
            subnet.add_ip(fake_network_cache_model.new_ip(
172
 
                        dict(address='192.168.1.102')))
173
 
        self.assertEqual(subnet['ips'],
174
 
                [fake_network_cache_model.new_ip(
175
 
                        dict(address='10.10.0.2')),
176
 
                 fake_network_cache_model.new_ip(
177
 
                        dict(address='10.10.0.3')),
178
 
                 fake_network_cache_model.new_ip(
179
 
                        dict(address='192.168.1.102'))])
180
 
 
181
 
    def test_hydrate(self):
182
 
        subnet_dict = {
183
 
            'cidr': '255.255.255.0',
184
 
            'dns': [fake_network_cache_model.new_ip(dict(address='1.1.1.1'))],
185
 
            'ips': [fake_network_cache_model.new_ip(dict(address='2.2.2.2'))],
186
 
            'routes': [fake_network_cache_model.new_route()],
187
 
            'version': 4,
188
 
            'gateway': fake_network_cache_model.new_ip(
189
 
                            dict(address='3.3.3.3'))}
190
 
        subnet = model.Subnet.hydrate(subnet_dict)
191
 
 
192
 
        self.assertEqual(subnet['cidr'], '255.255.255.0')
193
 
        self.assertEqual(subnet['dns'], [fake_network_cache_model.new_ip(
194
 
                                         dict(address='1.1.1.1'))])
195
 
        self.assertEqual(subnet['gateway']['address'], '3.3.3.3')
196
 
        self.assertEqual(subnet['ips'], [fake_network_cache_model.new_ip(
197
 
                                         dict(address='2.2.2.2'))])
198
 
        self.assertEqual(subnet['routes'], [
199
 
                    fake_network_cache_model.new_route()])
200
 
        self.assertEqual(subnet['version'], 4)
201
 
 
202
 
 
203
 
class NetworkTests(test.TestCase):
204
 
    def test_create_network(self):
205
 
        network = fake_network_cache_model.new_network()
206
 
        self.assertEqual(network['id'], 1)
207
 
        self.assertEqual(network['bridge'], 'br0')
208
 
        self.assertEqual(network['label'], 'public')
209
 
        self.assertEqual(network['subnets'],
210
 
                [fake_network_cache_model.new_subnet(),
211
 
                 fake_network_cache_model.new_subnet(
212
 
                        dict(cidr='255.255.255.255'))])
213
 
 
214
 
    def test_add_subnet(self):
215
 
        network = fake_network_cache_model.new_network()
216
 
        network.add_subnet(fake_network_cache_model.new_subnet(
217
 
                    dict(cidr='0.0.0.0')))
218
 
        self.assertEqual(network['subnets'],
219
 
                [fake_network_cache_model.new_subnet(),
220
 
                 fake_network_cache_model.new_subnet(
221
 
                        dict(cidr='255.255.255.255')),
222
 
                 fake_network_cache_model.new_subnet(dict(cidr='0.0.0.0'))])
223
 
 
224
 
    def test_add_subnet_a_lot(self):
225
 
        network = fake_network_cache_model.new_network()
226
 
        for i in xrange(10):
227
 
            network.add_subnet(fake_network_cache_model.new_subnet(
228
 
                    dict(cidr='0.0.0.0')))
229
 
        self.assertEqual(network['subnets'],
230
 
                [fake_network_cache_model.new_subnet(),
231
 
                 fake_network_cache_model.new_subnet(
232
 
                        dict(cidr='255.255.255.255')),
233
 
                 fake_network_cache_model.new_subnet(dict(cidr='0.0.0.0'))])
234
 
 
235
 
    def test_hydrate(self):
236
 
        new_network = dict(
237
 
            id=1,
238
 
            bridge='br0',
239
 
            label='public',
240
 
            subnets=[fake_network_cache_model.new_subnet(),
241
 
                fake_network_cache_model.new_subnet(
242
 
                        dict(cidr='255.255.255.255'))])
243
 
        network = model.Network.hydrate(fake_network_cache_model.new_network())
244
 
 
245
 
        self.assertEqual(network['id'], 1)
246
 
        self.assertEqual(network['bridge'], 'br0')
247
 
        self.assertEqual(network['label'], 'public')
248
 
        self.assertEqual(network['subnets'],
249
 
                [fake_network_cache_model.new_subnet(),
250
 
                 fake_network_cache_model.new_subnet(
251
 
                        dict(cidr='255.255.255.255'))])
252
 
 
253
 
 
254
 
class VIFTests(test.TestCase):
255
 
    def test_create_vif(self):
256
 
        vif = fake_network_cache_model.new_vif()
257
 
        self.assertEqual(vif['id'], 1)
258
 
        self.assertEqual(vif['address'], 'aa:aa:aa:aa:aa:aa')
259
 
        self.assertEqual(vif['network'],
260
 
                fake_network_cache_model.new_network())
261
 
 
262
 
    def test_vif_get_fixed_ips(self):
263
 
        vif = fake_network_cache_model.new_vif()
264
 
        fixed_ips = vif.fixed_ips()
265
 
        ips = [fake_network_cache_model.new_ip(dict(address='10.10.0.2')),
266
 
                fake_network_cache_model.new_ip(
267
 
                        dict(address='10.10.0.3'))] * 2
268
 
        self.assertEqual(fixed_ips, ips)
269
 
 
270
 
    def test_vif_get_floating_ips(self):
271
 
        vif = fake_network_cache_model.new_vif()
272
 
        vif['network']['subnets'][0]['ips'][0].add_floating_ip('192.168.1.1')
273
 
        floating_ips = vif.floating_ips()
274
 
        self.assertEqual(floating_ips, ['192.168.1.1'])
275
 
 
276
 
    def test_vif_get_labeled_ips(self):
277
 
        vif = fake_network_cache_model.new_vif()
278
 
        labeled_ips = vif.labeled_ips()
279
 
        ip_dict = {
280
 
            'network_id': 1,
281
 
            'ips': [fake_network_cache_model.new_ip(
282
 
                        {'address': '10.10.0.2'}),
283
 
                    fake_network_cache_model.new_ip(
284
 
                        {'address': '10.10.0.3'})] * 2,
285
 
            'network_label': 'public'}
286
 
        self.assertEqual(labeled_ips, ip_dict)
287
 
 
288
 
    def test_hydrate(self):
289
 
        new_vif = dict(
290
 
            id=1,
291
 
            address='127.0.0.1',
292
 
            network=fake_network_cache_model.new_network())
293
 
        vif = model.VIF.hydrate(fake_network_cache_model.new_vif())
294
 
        self.assertEqual(vif['id'], 1)
295
 
        self.assertEqual(vif['address'], 'aa:aa:aa:aa:aa:aa')
296
 
        self.assertEqual(vif['network'],
297
 
                fake_network_cache_model.new_network())
298
 
 
299
 
 
300
 
class NetworkInfoTests(test.TestCase):
301
 
    def test_create_model(self):
302
 
        ninfo = model.NetworkInfo([fake_network_cache_model.new_vif(),
303
 
                fake_network_cache_model.new_vif(
304
 
                    {'address':'bb:bb:bb:bb:bb:bb'})])
305
 
        self.assertEqual(ninfo.fixed_ips(),
306
 
                [fake_network_cache_model.new_ip({'address': '10.10.0.2'}),
307
 
                 fake_network_cache_model.new_ip(
308
 
                    {'address': '10.10.0.3'})] * 4)
309
 
 
310
 
    def test_get_floating_ips(self):
311
 
        vif = fake_network_cache_model.new_vif()
312
 
        vif['network']['subnets'][0]['ips'][0].add_floating_ip('192.168.1.1')
313
 
        ninfo = model.NetworkInfo([vif,
314
 
                fake_network_cache_model.new_vif(
315
 
                    {'address':'bb:bb:bb:bb:bb:bb'})])
316
 
        self.assertEqual(ninfo.floating_ips(), ['192.168.1.1'])
317
 
 
318
 
    def test_hydrate(self):
319
 
        ninfo = model.NetworkInfo([fake_network_cache_model.new_vif(),
320
 
                fake_network_cache_model.new_vif(
321
 
                        {'address':'bb:bb:bb:bb:bb:bb'})])
322
 
        deserialized = model.NetworkInfo.hydrate(ninfo)
323
 
        self.assertEqual(ninfo.fixed_ips(),
324
 
                [fake_network_cache_model.new_ip({'address': '10.10.0.2'}),
325
 
                 fake_network_cache_model.new_ip(
326
 
                        {'address': '10.10.0.3'})] * 4)