← Back to branch summary

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

« back to all changes in this revision

Viewing changes to nova/tests/network/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/network/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)