def test_contains_routes_between_nodes_on_same_vlan(self):
vlan = factory.make_VLAN()
network1 = factory.make_ip4_or_6_network()
network2 = factory.make_ip4_or_6_network(version=network1.version)
node1, if1, sn1, sip1 = self.make_node_with_address(network1,
vlan=vlan)
node2, if2, sn2, sip2 = self.make_node_with_address(network2,
vlan=vlan)
# Routes between all addresses are found, even back to themselves.
left = node1.id, if1.id, sn1.id, sn1.vlan.id, sip1.ip
right = node2.id, if2.id, sn2.id, sn2.vlan.id, sip2.ip
def row(ent1, ent2, metric):
return (*ent1, *ent2, None, metric)
expected = [
row(left, left, 0),
row(left, right, 2), # Same VLAN, hence metric of 2.
row(right, right, 0),
row(right, left, 2), # Same VLAN, hence metric of 2.
]
with connection.cursor() as cursor:
cursor.execute("SELECT * from maasserver_routable_pairs")
self.assertItemsEqual(expected, cursor.fetchall())
def test__does_not_contain_routes_between_nodes_on_differing_spaces(self):
space1 = factory.make_Space()
space2 = factory.make_Space()
network1 = factory.make_ip4_or_6_network()
network2 = factory.make_ip4_or_6_network(version=network1.version)
node1, ip1 = self.make_node_with_address(space1, network1)
node2, ip2 = self.make_node_with_address(space2, network2)
expected = []
# No routable addresses are found.
self.assertItemsEqual(expected,
find_addresses_between_nodes([node1], [node2]))
def test__does_not_contain_routes_between_addrs_of_diff_network_fams(self):
space = factory.make_Space() # One space.
network1 = factory.make_ip4_or_6_network()
network2 = factory.make_ip4_or_6_network(
version=(4 if network1.version == 6 else 6))
node1, ip1 = self.make_node_with_address(space, network1)
node2, ip2 = self.make_node_with_address(space, network2)
expected = []
# No routable addresses are found.
self.assertItemsEqual(expected,
find_addresses_between_nodes([node1], [node2]))
def test__yields_routes_between_nodes_on_same_space(self):
space = factory.make_Space()
network1 = factory.make_ip4_or_6_network()
network2 = factory.make_ip4_or_6_network(version=network1.version)
node1, ip1 = self.make_node_with_address(space, network1)
node2, ip2 = self.make_node_with_address(space, network2)
left = node1, ip1
right = node2, ip2
expected = [left + right]
# A route from node1 to node2 is found.
self.assertItemsEqual(expected,
find_addresses_between_nodes([node1], [node2]))
def test__creates_subnet(self):
subnet_name = factory.make_name("subnet")
subnet_description = factory.make_name("description")
vlan = factory.make_VLAN()
network = factory.make_ip4_or_6_network()
cidr = str(network.cidr)
gateway_ip = factory.pick_ip_in_network(network)
dns_servers = []
for _ in range(2):
dns_servers.append(
factory.pick_ip_in_network(network,
but_not=[gateway_ip] + dns_servers))
form = SubnetForm({
"name": subnet_name,
"description": subnet_description,
"vlan": vlan.id,
"cidr": cidr,
"gateway_ip": gateway_ip,
"dns_servers": ",".join(dns_servers),
})
self.assertTrue(form.is_valid(), dict(form.errors))
subnet = form.save()
self.assertThat(
subnet,
MatchesStructure.byEquality(
name=subnet_name,
description=subnet_description,
vlan=vlan,
cidr=cidr,
gateway_ip=gateway_ip,
dns_servers=dns_servers,
),
)
def test__updates_subnet(self):
new_name = factory.make_name("subnet")
new_description = factory.make_name("description")
subnet = factory.make_Subnet()
new_vlan = factory.make_VLAN()
new_network = factory.make_ip4_or_6_network()
new_cidr = str(new_network.cidr)
new_gateway_ip = factory.pick_ip_in_network(new_network)
new_dns_servers = []
for _ in range(2):
new_dns_servers.append(
factory.pick_ip_in_network(new_network,
but_not=[new_gateway_ip] +
new_dns_servers))
form = SubnetForm(instance=subnet,
data={
"name": new_name,
"description": new_description,
"vlan": new_vlan.id,
"cidr": new_cidr,
"gateway_ip": new_gateway_ip,
"dns_servers": ','.join(new_dns_servers),
})
self.assertTrue(form.is_valid(), dict(form.errors))
form.save()
subnet = reload_object(subnet)
self.assertThat(
subnet,
MatchesStructure.byEquality(name=new_name,
description=new_description,
vlan=new_vlan,
cidr=new_cidr,
gateway_ip=new_gateway_ip,
dns_servers=new_dns_servers))
def test_create_defaults_to_managed(self):
self.become_admin()
subnet_name = factory.make_name("subnet")
vlan = factory.make_VLAN()
network = factory.make_ip4_or_6_network()
cidr = str(network.cidr)
rdns_mode = factory.pick_choice(RDNS_MODE_CHOICES)
gateway_ip = factory.pick_ip_in_network(network)
dns_servers = []
for _ in range(2):
dns_servers.append(
factory.pick_ip_in_network(
network, but_not=[gateway_ip] + dns_servers))
uri = get_subnets_uri()
response = self.client.post(uri, {
"name": subnet_name,
"vlan": vlan.id,
"cidr": cidr,
"gateway_ip": gateway_ip,
"dns_servers": ','.join(dns_servers),
"rdns_mode": rdns_mode,
})
self.assertEqual(
http.client.OK, response.status_code, response.content)
created_subnet = json.loads(
response.content.decode(settings.DEFAULT_CHARSET))
self.assertEqual(subnet_name, created_subnet['name'])
self.assertEqual(vlan.vid, created_subnet['vlan']['vid'])
self.assertEqual(cidr, created_subnet['cidr'])
self.assertEqual(gateway_ip, created_subnet['gateway_ip'])
self.assertEqual(dns_servers, created_subnet['dns_servers'])
self.assertEqual(rdns_mode, created_subnet['rdns_mode'])
self.assertEqual(True, created_subnet['managed'])
def test_create(self):
self.become_admin()
subnet_name = factory.make_name("subnet")
vlan = factory.make_VLAN()
network = factory.make_ip4_or_6_network()
cidr = str(network.cidr)
rdns_mode = factory.pick_choice(RDNS_MODE_CHOICES)
allow_proxy = factory.pick_bool()
allow_dns = factory.pick_bool()
gateway_ip = factory.pick_ip_in_network(network)
managed = factory.pick_bool()
description = factory.make_string()
dns_servers = []
for _ in range(2):
dns_servers.append(
factory.pick_ip_in_network(network,
but_not=[gateway_ip] + dns_servers))
disabled_arches = random.sample(
[
boot_method.name for _, boot_method in BootMethodRegistry
if boot_method.arch_octet or boot_method.path_prefix_http
],
3,
)
uri = get_subnets_uri()
response = self.client.post(
uri,
{
"name": subnet_name,
"vlan": vlan.id,
"cidr": cidr,
"gateway_ip": gateway_ip,
"dns_servers": ",".join(dns_servers),
"rdns_mode": rdns_mode,
"allow_proxy": allow_proxy,
"allow_dns": allow_dns,
"managed": managed,
"description": description,
"disabled_boot_architectures": ",".join(disabled_arches),
},
)
self.assertEqual(http.client.OK, response.status_code,
response.content)
created_subnet = json.loads(
response.content.decode(settings.DEFAULT_CHARSET))
self.assertEqual(subnet_name, created_subnet["name"])
self.assertEqual(vlan.vid, created_subnet["vlan"]["vid"])
self.assertEqual(cidr, created_subnet["cidr"])
self.assertEqual(gateway_ip, created_subnet["gateway_ip"])
self.assertEqual(dns_servers, created_subnet["dns_servers"])
self.assertEqual(rdns_mode, created_subnet["rdns_mode"])
self.assertEqual(allow_proxy, created_subnet["allow_proxy"])
self.assertEqual(allow_dns, created_subnet["allow_dns"])
self.assertEqual(managed, created_subnet["managed"])
self.assertEqual(description, created_subnet["description"])
self.assertEqual(
sorted(disabled_arches),
sorted(created_subnet["disabled_boot_architectures"]),
)
def test_make_StaticIPAddress_uses_vlan_for_subnet_with_cidr(self):
iface = factory.make_Interface() # Specifies a VLAN.
network = factory.make_ip4_or_6_network()
sip = factory.make_StaticIPAddress(interface=iface, cidr=network)
self.assertThat(sip.subnet.vlan, Equals(iface.vlan))
self.assertThat({iface.vlan
for iface in sip.interface_set.all()},
Contains(iface.vlan))
def test_does_not_contain_routes_between_addrs_of_diff_network_fams(self):
space = factory.make_Space() # One space.
network1 = factory.make_ip4_or_6_network()
network2 = factory.make_ip4_or_6_network(
version=(4 if network1.version == 6 else 6))
node1, if1, sn1, sip1 = self.make_node_with_address(network1, space)
node2, if2, sn2, sip2 = self.make_node_with_address(network2, space)
# Only routes from left to left and right to right are found: right is
# not routable from left, and left is not routable from right because
# the address families differ.
left = node1.id, if1.id, sn1.id, sn1.vlan.id, sip1.ip
right = node2.id, if2.id, sn2.id, sn2.vlan.id, sip2.ip
expected = [(*left, *left, space.id, 0), (*right, *right, space.id, 0)]
with connection.cursor() as cursor:
cursor.execute("SELECT * from maasserver_routable_pairs")
self.assertItemsEqual(expected, cursor.fetchall())
def test__error_for_vlan_not_in_fabric(self):
fabric = factory.make_Fabric()
vlan = factory.make_VLAN(fabric=Fabric.objects.get_default_fabric())
network = factory.make_ip4_or_6_network()
cidr = str(network.cidr)
form = SubnetForm({"cidr": cidr, "fabric": fabric.id, "vlan": vlan.id})
self.assertFalse(form.is_valid(), dict(form.errors))
self.assertEqual(
{"vlan": ["VLAN %s is not in fabric %s." % (vlan, fabric)]},
dict(form.errors),
)
def test__creates_subnet_in_default_fabric_with_vid(self):
vlan = factory.make_VLAN(fabric=Fabric.objects.get_default_fabric())
network = factory.make_ip4_or_6_network()
cidr = str(network.cidr)
form = SubnetForm({"cidr": cidr, "vid": vlan.vid, "vlan": None})
self.assertTrue(form.is_valid(), dict(form.errors))
subnet = form.save()
self.assertThat(
subnet,
MatchesStructure.byEquality(name=cidr, cidr=cidr, vlan=vlan),
)
def test__error_for_unknown_vid_in_default_fabric(self):
fabric = factory.make_Fabric()
vlan = factory.make_VLAN(fabric=fabric)
network = factory.make_ip4_or_6_network()
cidr = str(network.cidr)
form = SubnetForm({"cidr": cidr, "vid": vlan.vid})
self.assertFalse(form.is_valid(), dict(form.errors))
self.assertEqual(
{"vid": ["No VLAN with vid %s in default fabric." % vlan.vid]},
dict(form.errors),
)
def test__contains_routes_between_nodes_via_null_space(self):
network1 = factory.make_ip4_or_6_network()
network2 = factory.make_ip4_or_6_network(version=network1.version)
node1, if1, sn1, sip1 = self.make_node_with_address(network1)
node2, if2, sn2, sip2 = self.make_node_with_address(network2)
# Routes between all addresses are found, even back to themselves.
left = node1.id, if1.id, sn1.id, sn1.vlan.id, sip1.ip
right = node2.id, if2.id, sn2.id, sn2.vlan.id, sip2.ip
row = lambda ent1, ent2, metric: (*ent1, *ent2, None, metric)
expected = [
row(left, left, 0),
row(left, right, 4), # The NULL space, hence metric of 4.
row(right, right, 0),
row(right, left, 4), # The NULL space, hence metric of 4.
]
with connection.cursor() as cursor:
cursor.execute("SELECT * from maasserver_routable_pairs")
self.assertItemsEqual(expected, cursor.fetchall())
def test__creates_subnet_name_equal_to_cidr(self):
vlan = factory.make_VLAN()
network = factory.make_ip4_or_6_network()
cidr = str(network.cidr)
form = SubnetForm({"vlan": vlan.id, "cidr": cidr})
self.assertTrue(form.is_valid(), dict(form.errors))
subnet = form.save()
self.assertThat(
subnet,
MatchesStructure.byEquality(name=cidr, vlan=vlan, cidr=cidr),
)
def test__creates_subnet_in_default_vlan_in_fabric(self):
fabric = factory.make_Fabric()
network = factory.make_ip4_or_6_network()
cidr = str(network.cidr)
form = SubnetForm({"cidr": cidr, "fabric": fabric.id, "vlan": None})
self.assertTrue(form.is_valid(), dict(form.errors))
subnet = form.save()
self.assertThat(
subnet,
MatchesStructure.byEquality(name=cidr,
cidr=cidr,
vlan=fabric.get_default_vlan()),
)
def test__yields_routes_between_multiple_nodes_on_same_space(self):
space = factory.make_Space()
lefts, rights = [], []
for index in range(3):
network1 = factory.make_ip4_or_6_network()
network2 = factory.make_ip4_or_6_network(version=network1.version)
lefts.append(self.make_node_with_address(space, network1))
rights.append(self.make_node_with_address(space, network2))
expected = [
(n1, ip1, n2, ip2)
for (n1, ip1), (n2, ip2) in product(lefts, rights)
# Addresses are only routable when they're the same IP version.
if ip1.version == ip2.version
]
# A route from each node on the left is found to each on the right.
self.assertItemsEqual(
expected,
find_addresses_between_nodes((node for node, _ in lefts),
(node for node, _ in rights)))
def test__creates_subnet_in_default_fabric_and_vlan(self):
network = factory.make_ip4_or_6_network()
cidr = str(network.cidr)
form = SubnetForm({"cidr": cidr})
self.assertTrue(form.is_valid(), dict(form.errors))
subnet = form.save()
self.assertThat(
subnet,
MatchesStructure.byEquality(
name=cidr,
cidr=cidr,
vlan=Fabric.objects.get_default_fabric().get_default_vlan(),
),
)
def test_create(self):
self.become_admin()
subnet_name = factory.make_name("subnet")
vlan = factory.make_VLAN()
network = factory.make_ip4_or_6_network()
cidr = str(network.cidr)
rdns_mode = factory.pick_choice(RDNS_MODE_CHOICES)
allow_proxy = factory.pick_bool()
allow_dns = factory.pick_bool()
gateway_ip = factory.pick_ip_in_network(network)
managed = factory.pick_bool()
dns_servers = []
for _ in range(2):
dns_servers.append(
factory.pick_ip_in_network(
network, but_not=[gateway_ip] + dns_servers
)
)
uri = get_subnets_uri()
response = self.client.post(
uri,
{
"name": subnet_name,
"vlan": vlan.id,
"cidr": cidr,
"gateway_ip": gateway_ip,
"dns_servers": ",".join(dns_servers),
"rdns_mode": rdns_mode,
"allow_proxy": allow_proxy,
"allow_dns": allow_dns,
"managed": managed,
},
)
self.assertEqual(
http.client.OK, response.status_code, response.content
)
created_subnet = json.loads(
response.content.decode(settings.DEFAULT_CHARSET)
)
self.assertEqual(subnet_name, created_subnet["name"])
self.assertEqual(vlan.vid, created_subnet["vlan"]["vid"])
self.assertEqual(cidr, created_subnet["cidr"])
self.assertEqual(gateway_ip, created_subnet["gateway_ip"])
self.assertEqual(dns_servers, created_subnet["dns_servers"])
self.assertEqual(rdns_mode, created_subnet["rdns_mode"])
self.assertEqual(allow_proxy, created_subnet["allow_proxy"])
self.assertEqual(allow_dns, created_subnet["allow_dns"])
self.assertEqual(managed, created_subnet["managed"])
def test__error_for_unknown_vid_in_fabric(self):
fabric = factory.make_Fabric()
vlan = factory.make_VLAN(fabric=Fabric.objects.get_default_fabric())
network = factory.make_ip4_or_6_network()
cidr = str(network.cidr)
form = SubnetForm({
"cidr": cidr,
"fabric": fabric.id,
"vid": vlan.vid,
})
self.assertFalse(form.is_valid(), dict(form.errors))
self.assertEqual(
{
"vid":
["No VLAN with vid %s in fabric %s." % (vlan.vid, fabric)]
}, dict(form.errors))
def test__creates_subnet_in_fabric_with_vid(self):
fabric = factory.make_Fabric()
vlan = factory.make_VLAN(fabric=fabric)
network = factory.make_ip4_or_6_network()
cidr = str(network.cidr)
form = SubnetForm({
"cidr": cidr,
"fabric": fabric.id,
"vid": vlan.vid,
"vlan": None,
})
self.assertTrue(form.is_valid(), form.errors)
subnet = form.save()
self.assertThat(
subnet, MatchesStructure.byEquality(name=cidr,
cidr=cidr,
vlan=vlan))
def test__updates_subnet_name_to_cidr(self):
subnet = factory.make_Subnet()
subnet.name = subnet.cidr
subnet.save()
new_network = factory.make_ip4_or_6_network()
new_cidr = str(new_network.cidr)
new_gateway_ip = factory.pick_ip_in_network(new_network)
form = SubnetForm(instance=subnet,
data={
"cidr": new_cidr,
"gateway_ip": new_gateway_ip,
})
self.assertTrue(form.is_valid(), dict(form.errors))
form.save()
subnet = reload_object(subnet)
self.assertThat(
subnet,
MatchesStructure.byEquality(name=new_cidr,
cidr=new_cidr,
gateway_ip=new_gateway_ip))
