58
58
def test_allocate_new_sets_user(self):
59
59
low, high = factory.make_ip_range()
60
user = factory.make_user()
60
user = factory.make_User()
61
61
ipaddress = StaticIPAddress.objects.allocate_new(
62
62
low, high, alloc_type=IPADDRESS_TYPE.USER_RESERVED, user=user)
63
63
self.assertEqual(user, ipaddress.user)
65
65
def test_allocate_new_with_user_disallows_wrong_alloc_types(self):
66
66
low, high = factory.make_ip_range()
67
user = factory.make_user()
67
user = factory.make_User()
68
68
alloc_type = factory.pick_enum(
69
69
IPADDRESS_TYPE, but_not=[IPADDRESS_TYPE.USER_RESERVED])
83
83
# addresses. See https://bugs.launchpad.net/maas/+bug/1338452
85
85
high = "10.0.0.100"
86
factory.make_staticipaddress("10.0.0.99")
86
factory.make_StaticIPAddress("10.0.0.99")
87
87
ipaddress = StaticIPAddress.objects.allocate_new(low, high)
88
88
self.assertEqual(ipaddress.ip, "10.0.0.98")
137
137
def test_deallocate_by_node_removes_addresses(self):
138
node = factory.make_node()
138
node = factory.make_Node()
140
factory.make_mac_address(node=node) for _ in range(2)]
141
factory.make_staticipaddress(mac=mac1)
142
factory.make_staticipaddress(mac=mac2)
140
factory.make_MACAddress(node=node) for _ in range(2)]
141
factory.make_StaticIPAddress(mac=mac1)
142
factory.make_StaticIPAddress(mac=mac2)
143
143
StaticIPAddress.objects.deallocate_by_node(node)
144
144
# Check the DB is cleared.
145
145
self.assertEqual([], list(StaticIPAddress.objects.all()))
147
147
self.assertEqual([], list(node.static_ip_addresses()))
149
149
def test_deallocate_by_node_returns_deallocated_ips(self):
150
node = factory.make_node()
150
node = factory.make_Node()
152
factory.make_mac_address(node=node) for _ in range(2)]
153
ip1 = factory.make_staticipaddress(mac=mac1)
154
ip2 = factory.make_staticipaddress(mac=mac2)
152
factory.make_MACAddress(node=node) for _ in range(2)]
153
ip1 = factory.make_StaticIPAddress(mac=mac1)
154
ip2 = factory.make_StaticIPAddress(mac=mac2)
155
155
observed = StaticIPAddress.objects.deallocate_by_node(node)
156
156
self.assertItemsEqual(
157
157
[ip1.ip.format(), ip2.ip.format()],
161
161
def test_deallocate_by_node_ignores_other_nodes(self):
162
node1 = factory.make_node()
163
mac1 = factory.make_mac_address(node=node1)
164
factory.make_staticipaddress(mac=mac1)
165
node2 = factory.make_node()
166
mac2 = factory.make_mac_address(node=node2)
167
ip2 = factory.make_staticipaddress(mac=mac2)
162
node1 = factory.make_Node()
163
mac1 = factory.make_MACAddress(node=node1)
164
factory.make_StaticIPAddress(mac=mac1)
165
node2 = factory.make_Node()
166
mac2 = factory.make_MACAddress(node=node2)
167
ip2 = factory.make_StaticIPAddress(mac=mac2)
169
169
StaticIPAddress.objects.deallocate_by_node(node1)
170
170
self.assertItemsEqual([ip2.ip], node2.static_ip_addresses())
172
172
def test_deallocate_only_deletes_auto_types(self):
173
node = factory.make_node()
174
mac = factory.make_mac_address(node=node)
173
node = factory.make_Node()
174
mac = factory.make_MACAddress(node=node)
175
175
alloc_types = map_enum(IPADDRESS_TYPE).values()
176
176
for alloc_type in alloc_types:
177
factory.make_staticipaddress(mac=mac, alloc_type=alloc_type)
177
factory.make_StaticIPAddress(mac=mac, alloc_type=alloc_type)
179
179
StaticIPAddress.objects.deallocate_by_node(node)
180
180
types_without_auto = set(alloc_types)
184
184
[ip.alloc_type for ip in StaticIPAddress.objects.all()])
186
186
def test_delete_by_node_removes_addresses(self):
187
node = factory.make_node()
187
node = factory.make_Node()
189
factory.make_mac_address(node=node) for _ in range(2)]
190
factory.make_staticipaddress(mac=mac1)
191
factory.make_staticipaddress(mac=mac2)
189
factory.make_MACAddress(node=node) for _ in range(2)]
190
factory.make_StaticIPAddress(mac=mac1)
191
factory.make_StaticIPAddress(mac=mac2)
192
192
StaticIPAddress.objects.delete_by_node(node)
193
193
# Check the DB is cleared.
194
194
self.assertEqual([], list(StaticIPAddress.objects.all()))
196
196
self.assertEqual([], list(node.static_ip_addresses()))
198
198
def test_delete_by_node_returns_deallocated_ips(self):
199
node = factory.make_node()
199
node = factory.make_Node()
201
factory.make_mac_address(node=node) for _ in range(2)]
202
ip1 = factory.make_staticipaddress(mac=mac1)
203
ip2 = factory.make_staticipaddress(mac=mac2)
201
factory.make_MACAddress(node=node) for _ in range(2)]
202
ip1 = factory.make_StaticIPAddress(mac=mac1)
203
ip2 = factory.make_StaticIPAddress(mac=mac2)
204
204
observed = StaticIPAddress.objects.delete_by_node(node)
205
205
self.assertItemsEqual(
206
206
[ip1.ip.format(), ip2.ip.format()],
210
210
def test_delete_by_node_ignores_other_nodes(self):
211
node1 = factory.make_node()
212
mac1 = factory.make_mac_address(node=node1)
213
factory.make_staticipaddress(mac=mac1)
214
other_node = factory.make_node()
215
other_mac = factory.make_mac_address(node=other_node)
216
other_ip = factory.make_staticipaddress(mac=other_mac)
211
node1 = factory.make_Node()
212
mac1 = factory.make_MACAddress(node=node1)
213
factory.make_StaticIPAddress(mac=mac1)
214
other_node = factory.make_Node()
215
other_mac = factory.make_MACAddress(node=other_node)
216
other_ip = factory.make_StaticIPAddress(mac=other_mac)
218
218
StaticIPAddress.objects.delete_by_node(node1)
219
219
self.assertItemsEqual([other_ip.ip], other_node.static_ip_addresses())
221
221
def test_delete_by_node_deletes_all_types(self):
222
node = factory.make_node()
223
mac = factory.make_mac_address(node=node)
222
node = factory.make_Node()
223
mac = factory.make_MACAddress(node=node)
224
224
alloc_types = map_enum(IPADDRESS_TYPE).values()
225
225
for alloc_type in alloc_types:
226
factory.make_staticipaddress(mac=mac, alloc_type=alloc_type)
226
factory.make_StaticIPAddress(mac=mac, alloc_type=alloc_type)
228
228
StaticIPAddress.objects.delete_by_node(node)
229
229
self.assertItemsEqual([], StaticIPAddress.objects.all())
233
233
"""Tests for get_hostname_ip_mapping()."""
235
235
def test_get_hostname_ip_mapping_returns_mapping(self):
236
nodegroup = factory.make_node_group()
236
nodegroup = factory.make_NodeGroup()
237
237
expected_mapping = {}
238
238
for i in range(3):
239
239
node = factory.make_node_with_mac_attached_to_nodegroupinterface(
240
240
nodegroup=nodegroup)
241
staticip = factory.make_staticipaddress(mac=node.get_primary_mac())
241
staticip = factory.make_StaticIPAddress(mac=node.get_primary_mac())
242
242
expected_mapping[node.hostname] = [staticip.ip]
243
243
mapping = StaticIPAddress.objects.get_hostname_ip_mapping(nodegroup)
244
244
self.assertEqual(expected_mapping, mapping)
246
246
def test_get_hostname_ip_mapping_strips_out_domain(self):
247
nodegroup = factory.make_node_group()
247
nodegroup = factory.make_NodeGroup()
248
248
hostname = factory.make_name('hostname')
249
249
domain = factory.make_name('domain')
250
250
node = factory.make_node_with_mac_attached_to_nodegroupinterface(
251
251
nodegroup=nodegroup, hostname="%s.%s" % (hostname, domain))
252
staticip = factory.make_staticipaddress(mac=node.get_primary_mac())
252
staticip = factory.make_StaticIPAddress(mac=node.get_primary_mac())
253
253
mapping = StaticIPAddress.objects.get_hostname_ip_mapping(nodegroup)
254
254
self.assertEqual({hostname: [staticip.ip]}, mapping)
256
256
def test_get_hostname_ip_mapping_picks_mac_with_static_address(self):
257
257
node = factory.make_node_with_mac_attached_to_nodegroupinterface(
258
258
hostname=factory.make_name('host'))
259
second_mac = factory.make_mac_address(node=node)
260
staticip = factory.make_staticipaddress(mac=second_mac)
259
second_mac = factory.make_MACAddress(node=node)
260
staticip = factory.make_StaticIPAddress(mac=second_mac)
261
261
mapping = StaticIPAddress.objects.get_hostname_ip_mapping(
263
263
self.assertEqual({node.hostname: [staticip.ip]}, mapping)
265
265
def test_get_hostname_ip_mapping_considers_given_nodegroup(self):
266
nodegroup = factory.make_node_group()
266
nodegroup = factory.make_NodeGroup()
267
267
node = factory.make_node_with_mac_attached_to_nodegroupinterface(
268
268
nodegroup=nodegroup)
269
factory.make_staticipaddress(mac=node.get_primary_mac())
270
another_nodegroup = factory.make_node_group()
269
factory.make_StaticIPAddress(mac=node.get_primary_mac())
270
another_nodegroup = factory.make_NodeGroup()
271
271
mapping = StaticIPAddress.objects.get_hostname_ip_mapping(
272
272
another_nodegroup)
273
273
self.assertEqual({}, mapping)
275
275
def test_get_hostname_ip_mapping_picks_oldest_mac_with_static_ip(self):
276
276
node = factory.make_node_with_mac_attached_to_nodegroupinterface(
277
277
hostname=factory.make_name('host'))
278
newer_mac = factory.make_mac_address(node=node)
279
factory.make_staticipaddress(mac=newer_mac)
280
ip_for_older_mac = factory.make_staticipaddress(
278
newer_mac = factory.make_MACAddress(node=node)
279
factory.make_StaticIPAddress(mac=newer_mac)
280
ip_for_older_mac = factory.make_StaticIPAddress(
281
281
mac=node.get_primary_mac())
282
282
mapping = StaticIPAddress.objects.get_hostname_ip_mapping(
284
284
self.assertEqual({node.hostname: [ip_for_older_mac.ip]}, mapping)
286
286
def test_get_hostname_ip_mapping_combines_IPv4_and_IPv6_addresses(self):
287
node = factory.make_node(mac=True, disable_ipv4=False)
287
node = factory.make_Node(mac=True, disable_ipv4=False)
288
288
mac = node.get_primary_mac()
289
ipv4_address = factory.make_staticipaddress(
289
ipv4_address = factory.make_StaticIPAddress(
291
291
ip=factory.pick_ip_in_network(factory.getRandomNetwork()))
292
ipv6_address = factory.make_staticipaddress(
292
ipv6_address = factory.make_StaticIPAddress(
294
294
ip=factory.pick_ip_in_network(factory.make_ipv6_network()))
295
295
mapping = StaticIPAddress.objects.get_hostname_ip_mapping(
301
301
def test_get_hostname_ip_mapping_combines_MACs_for_same_node(self):
302
302
# A node's preferred static IPv4 and IPv6 addresses may be on
303
303
# different MACs.
304
node = factory.make_node(disable_ipv4=False)
305
ipv4_address = factory.make_staticipaddress(
306
mac=factory.make_mac_address(node=node),
304
node = factory.make_Node(disable_ipv4=False)
305
ipv4_address = factory.make_StaticIPAddress(
306
mac=factory.make_MACAddress(node=node),
307
307
ip=factory.pick_ip_in_network(factory.getRandomNetwork()))
308
ipv6_address = factory.make_staticipaddress(
309
mac=factory.make_mac_address(node=node),
308
ipv6_address = factory.make_StaticIPAddress(
309
mac=factory.make_MACAddress(node=node),
310
310
ip=factory.pick_ip_in_network(factory.make_ipv6_network()))
311
311
mapping = StaticIPAddress.objects.get_hostname_ip_mapping(
315
315
mapping[node.hostname])
317
317
def test_get_hostname_ip_mapping_skips_ipv4_if_disable_ipv4_set(self):
318
node = factory.make_node(mac=True, disable_ipv4=True)
318
node = factory.make_Node(mac=True, disable_ipv4=True)
319
319
mac = node.get_primary_mac()
320
factory.make_staticipaddress(
320
factory.make_StaticIPAddress(
322
322
ip=factory.pick_ip_in_network(factory.getRandomNetwork()))
323
ipv6_address = factory.make_staticipaddress(
323
ipv6_address = factory.make_StaticIPAddress(
325
325
ip=factory.pick_ip_in_network(factory.make_ipv6_network()))
326
326
mapping = StaticIPAddress.objects.get_hostname_ip_mapping(
331
331
class StaticIPAddressTest(MAASServerTestCase):
333
333
def test_repr_with_valid_type(self):
334
actual = "%s" % factory.make_staticipaddress(
334
actual = "%s" % factory.make_StaticIPAddress(
335
335
ip="10.0.0.1", alloc_type=IPADDRESS_TYPE.AUTO)
336
336
self.assertEqual("<StaticIPAddress: <10.0.0.1:type=AUTO>>", actual)
338
338
def test_repr_with_invalid_type(self):
339
actual = "%s" % factory.make_staticipaddress(
339
actual = "%s" % factory.make_StaticIPAddress(
340
340
ip="10.0.0.1", alloc_type=99999)
341
341
self.assertEqual("<StaticIPAddress: <10.0.0.1:type=99999>>", actual)
343
343
def test_stores_to_database(self):
344
ipaddress = factory.make_staticipaddress()
344
ipaddress = factory.make_StaticIPAddress()
345
345
self.assertEqual([ipaddress], list(StaticIPAddress.objects.all()))
347
347
def test_invalid_address_raises_validation_error(self):
349
349
self.assertRaises(ValidationError, ip.full_clean)
351
351
def test_deallocate_removes_object(self):
352
ipaddress = factory.make_staticipaddress()
352
ipaddress = factory.make_StaticIPAddress()
353
353
ipaddress.deallocate()
354
354
self.assertEqual([], list(StaticIPAddress.objects.all()))
356
356
def test_deallocate_ignores_other_objects(self):
357
ipaddress = factory.make_staticipaddress()
358
ipaddress2 = factory.make_staticipaddress()
357
ipaddress = factory.make_StaticIPAddress()
358
ipaddress2 = factory.make_StaticIPAddress()
359
359
ipaddress.deallocate()
360
360
self.assertEqual([ipaddress2], list(StaticIPAddress.objects.all()))
added
removed
src/maasserver/models/tests/test_staticipaddress.py
