def test_adds_connected_rack_ipv4(self):
rack = factory.make_RackController()
factory.make_RegionRackRPCConnection(rack)
nic = rack.get_boot_interface()
network = factory.make_ipv4_network()
subnet = factory.make_Subnet(cidr=str(network.cidr))
static_ip = factory.make_StaticIPAddress(
alloc_type=IPADDRESS_TYPE.AUTO,
ip=factory.pick_ip_in_Subnet(subnet),
subnet=subnet,
interface=nic,
)
domain = get_internal_domain()
self.assertEqual(get_resource_name_for_subnet(subnet),
domain.resources[0].name)
self.assertEqual(
InternalDomainResourseRecord(rrtype="A", rrdata=static_ip.ip),
domain.resources[0].records[0],
)
def test__link_id_fields_setup_correctly(self):
interface = factory.make_Interface(INTERFACE_TYPE.PHYSICAL)
links = []
for _ in range(2):
links.append(
self.make_ip_family_link(
interface, factory.make_ipv4_network()
)
)
for _ in range(2):
links.append(
self.make_ip_family_link(
interface, factory.make_ipv6_network()
)
)
link_ids = [link.id for link in links]
form = InterfaceSetDefaultGatwayForm(instance=interface, data={})
choice_ids = [choice[0] for choice in form.fields["link_id"].choices]
self.assertItemsEqual(link_ids, choice_ids)
def test__AUTO_sets_node_gateway_link_v4(self):
interface = factory.make_Interface(INTERFACE_TYPE.PHYSICAL)
network = factory.make_ipv4_network()
auto_subnet = factory.make_Subnet(
cidr=str(network.cidr), vlan=interface.vlan
)
form = InterfaceLinkForm(
instance=interface,
data={
"mode": INTERFACE_LINK_TYPE.AUTO,
"subnet": auto_subnet.id,
"default_gateway": True,
},
)
self.assertTrue(form.is_valid(), form.errors)
interface = form.save()
auto_ip = interface.ip_addresses.get(alloc_type=IPADDRESS_TYPE.AUTO)
node = interface.get_node()
self.assertEqual(auto_ip, node.gateway_link_ipv4)
def test_STATIC_sets_node_gateway_link_ipv4(self):
interface = factory.make_Interface(INTERFACE_TYPE.PHYSICAL)
network = factory.make_ipv4_network()
subnet = factory.make_Subnet(cidr=str(network.cidr),
vlan=interface.vlan)
form = InterfaceLinkForm(
instance=interface,
data={
"mode": INTERFACE_LINK_TYPE.STATIC,
"subnet": subnet.id,
"default_gateway": True,
},
)
self.assertTrue(form.is_valid(), form.errors)
interface = form.save()
ip_address = get_one(
interface.ip_addresses.filter(alloc_type=IPADDRESS_TYPE.STICKY,
subnet=subnet))
node = interface.get_node()
self.assertEqual(ip_address, node.gateway_link_ipv4)
def test__prefers_static_ip_over_dhcp(self):
rack = factory.make_RackController()
factory.make_RegionRackRPCConnection(rack)
nic = rack.get_boot_interface()
network = factory.make_ipv4_network()
subnet = factory.make_Subnet(cidr=str(network.cidr))
static_ip = factory.make_StaticIPAddress(
alloc_type=IPADDRESS_TYPE.AUTO,
ip=factory.pick_ip_in_Subnet(subnet),
subnet=subnet, interface=nic)
factory.make_StaticIPAddress(
alloc_type=IPADDRESS_TYPE.DHCP,
ip=factory.pick_ip_in_Subnet(subnet),
subnet=subnet, interface=nic)
domain = get_internal_domain()
self.assertThat(domain.resources, HasLength(1))
self.assertEqual(
get_resource_name_for_subnet(subnet), domain.resources[0].name)
self.assertEqual(
InternalDomainResourseRecord(rrtype='A', rrdata=static_ip.ip),
domain.resources[0].records[0])
def test_STATIC_not_allowed_if_ip_address_not_in_subnet(self):
interface = factory.make_Interface(INTERFACE_TYPE.PHYSICAL)
network = factory.make_ipv4_network()
subnet = factory.make_Subnet(vlan=interface.vlan,
cidr=str(network.cidr))
ip_not_in_subnet = factory.make_ipv6_address()
form = InterfaceLinkForm(
instance=interface,
data={
"mode": INTERFACE_LINK_TYPE.STATIC,
"subnet": subnet.id,
"ip_address": ip_not_in_subnet,
},
)
self.assertFalse(form.is_valid(), form.errors)
self.assertEqual(
{
"ip_address":
["IP address is not in the given subnet '%s'." % subnet]
},
form.errors,
)
def test__adds_connected_multiple_racks_ipv4(self):
rack1 = factory.make_RackController()
factory.make_RegionRackRPCConnection(rack1)
rack2 = factory.make_RackController()
factory.make_RegionRackRPCConnection(rack2)
network = factory.make_ipv4_network()
subnet = factory.make_Subnet(cidr=str(network.cidr))
static_ip1 = factory.make_StaticIPAddress(
alloc_type=IPADDRESS_TYPE.AUTO,
ip=factory.pick_ip_in_Subnet(subnet),
subnet=subnet, interface=rack1.get_boot_interface())
static_ip2 = factory.make_StaticIPAddress(
alloc_type=IPADDRESS_TYPE.AUTO,
ip=factory.pick_ip_in_Subnet(subnet),
subnet=subnet, interface=rack2.get_boot_interface())
domain = get_internal_domain()
self.assertEqual(
get_resource_name_for_subnet(subnet),
domain.resources[0].name)
self.assertThat(domain.resources[0].records, MatchesSetwise(
Equals(InternalDomainResourseRecord(
rrtype='A', rrdata=static_ip1.ip)),
Equals(InternalDomainResourseRecord(
rrtype='A', rrdata=static_ip2.ip))))
def test_settings_dns_POST(self):
# Disable boot source cache signals.
self.addCleanup(bootsources.signals.enable)
bootsources.signals.disable()
self.client.login(user=factory.make_admin())
new_upstream = "8.8.8.8 8.8.4.4"
new_ipv4_subnet = factory.make_ipv4_network()
new_ipv6_subnet = factory.make_ipv6_network()
new_subnets = "%s %s" % (new_ipv4_subnet, new_ipv6_subnet)
response = self.client.post(
reverse('settings_network'),
get_prefixed_form_data(prefix='dns',
data={
'upstream_dns': new_upstream,
'dnssec_validation': 'no',
'dns_trusted_acl': new_subnets,
}))
self.assertEqual(http.client.FOUND, response.status_code,
response.content)
self.assertEqual(new_upstream,
Config.objects.get_config('upstream_dns'))
self.assertEqual('no', Config.objects.get_config('dnssec_validation'))
self.assertEqual(new_subnets,
Config.objects.get_config('dns_trusted_acl'))
def test__returns_full_list_for_empty_subnet(self):
subnet = factory.make_Subnet(
cidr=factory.make_ipv4_network(), dns_servers=[], gateway_ip=""
)
network = subnet.get_ipnetwork()
response = self.client.get(
get_subnet_uri(subnet), {"op": "unreserved_ip_ranges"}
)
self.assertEqual(
http.client.OK,
response.status_code,
explain_unexpected_response(http.client.OK, response),
)
result = json.loads(response.content.decode(settings.DEFAULT_CHARSET))
expected_addresses = network.last - network.first + 1
expected_first_address = inet_ntop(network.first + 1)
if network.version == 6:
# Don't count the IPv6 network address in num_addresses
expected_addresses -= 1
expected_last_address = inet_ntop(network.last)
else:
# Don't count the IPv4 broadcast/network addresses in num_addresses
expected_addresses -= 2
expected_last_address = inet_ntop(network.last - 1)
self.assertThat(
result,
Equals(
[
{
"start": expected_first_address,
"end": expected_last_address,
"num_addresses": expected_addresses,
}
]
),
)
def test_POST_reserve_errors_for_no_matching_subnet(self):
network = factory.make_ipv4_network()
factory.make_Subnet(cidr=str(network.cidr))
other_net = factory.make_ipv4_network(but_not=[network])
response = self.post_reservation_request(network=other_net)
self.assertNoMatchingNetworkError(response, other_net)
def test_rejects_invalid_ipv4_subnet(self):
input = "%s 10.10.10.300/24" % factory.make_ipv4_network()
error = self.assertRaises(ValidationError,
SubnetListFormField().clean, input)
self.assertThat(error.message,
Equals("Invalid network: 10.10.10.300/24."))
def test_accepts_comma_separated_subnets(self):
subnets = [str(factory.make_ipv4_network()) for _ in range(5)]
input = ",".join(subnets)
self.assertEqual(" ".join(subnets), SubnetListFormField().clean(input))
def test_accepts_single_subnet(self):
subnet = str(factory.make_ipv4_network())
self.assertEqual(subnet, SubnetListFormField().clean(subnet))
def test_rejects_undersize_overlay(self):
slash = random.randint(4, 28)
with ExpectedException(ValidationError):
factory.make_FanNetwork(
underlay=factory.make_ipv4_network(slash=slash),
overlay=factory.make_ipv4_network(slash=slash + 2))
def test_rejects_host_reserve_too_big(self):
with ExpectedException(ValidationError):
factory.make_FanNetwork(
underlay=factory.make_ipv4_network(slash=16),
overlay=factory.make_ipv4_network(slash=8),
host_reserve=256)
def test__doesnt_require_link_id_if_only_one_gateway_per_family(self):
interface = factory.make_Interface(INTERFACE_TYPE.PHYSICAL)
self.make_ip_family_link(interface, factory.make_ipv4_network())
self.make_ip_family_link(interface, factory.make_ipv6_network())
form = InterfaceSetDefaultGatwayForm(instance=interface, data={})
self.assertTrue(form.is_valid(), form.errors)
