def test__delete_as_non_admin_asserts(self):
user = factory.make_User()
handler = SpaceHandler(user, {})
space = factory.make_Space()
with ExpectedException(AssertionError, "Permission denied."):
handler.delete({
"id": space.id,
})
def test_delete_deletes_space(self):
self.become_admin()
space = factory.make_Space()
uri = get_space_uri(space)
response = self.client.delete(uri)
self.assertEqual(http.client.NO_CONTENT, response.status_code,
response.content)
self.assertIsNone(reload_object(space))
def test_update_sets_space_by_specifier(self):
vlan = factory.make_VLAN()
space = factory.make_Space()
form = VLANForm(instance=vlan, data={"space": "name:" + space.name})
self.assertTrue(form.is_valid(), form.errors)
form.save()
vlan = reload_object(vlan)
self.assertEquals(space.id, vlan.space.id)
def test_update_clears_space_when_None(self):
space = factory.make_Space()
vlan = factory.make_VLAN(space=space)
form = VLANForm(instance=vlan, data={"space": None})
self.assertTrue(form.is_valid(), form.errors)
form.save()
vlan = reload_object(vlan)
self.assertIsNone(vlan.space)
def test__reloads_user(self):
user = factory.make_admin()
handler = SpaceHandler(user, {}, None)
space = factory.make_Space()
user.is_superuser = False
user.save()
with ExpectedException(AssertionError, "Permission denied."):
handler.delete({"id": space.id})
def test_update_admin_only(self):
space = factory.make_Space()
new_name = factory.make_name("space")
uri = get_space_uri(space)
response = self.client.put(uri, {
"name": new_name,
})
self.assertEqual(http.client.FORBIDDEN, response.status_code,
response.content)
def test__space_specifier_matches_space_by_id(self):
factory.make_VLAN()
space = factory.make_Space()
vlan = factory.make_VLAN(space=space)
factory.make_VLAN()
self.assertItemsEqual(
VLAN.objects.filter_by_specifiers('space:%s' % space.id),
[vlan]
)
def create_device_with_parent(self, params=None):
if params is None:
params = {}
vlan = factory.make_VLAN(space=factory.make_Space())
parent = factory.make_Node(with_boot_disk=False)
params["node_type"] = NODE_TYPE.DEVICE
params["parent"] = parent
device = factory.make_Node(vlan=vlan, **params)
return device, parent
def test__user_view_returns_space(self):
user = factory.make_User()
space = factory.make_Space()
self.assertEqual(
space,
Space.objects.get_space_or_404(
space.id, user, NodePermission.view
),
)
def test__delete_as_admin_success(self):
user = factory.make_admin()
handler = SpaceHandler(user, {}, None)
space = factory.make_Space()
handler.delete({
"id": space.id,
})
space = reload_object(space)
self.assertThat(space, Equals(None))
def test__admin_admin_returns_space(self):
admin = factory.make_admin()
space = factory.make_Space()
self.assertEqual(
space,
Space.objects.get_space_or_404(
space.id, admin, NodePermission.admin
),
)
def test__user_admin_raises_PermissionError(self):
user = factory.make_User()
space = factory.make_Space()
self.assertRaises(
PermissionDenied,
Space.objects.get_space_or_404,
space.id,
user,
NodePermission.admin,
)
def test_create_as_admin_succeeds_even_with_a_specified_space(self):
user = factory.make_admin()
handler = SubnetHandler(user, {}, None)
vlan = factory.make_VLAN()
space = factory.make_Space()
result = handler.create(
{"vlan": vlan.id, "cidr": "192.168.0.0/24", "space": space.id}
)
subnet = Subnet.objects.get(id=result["id"])
self.assertThat(subnet.cidr, Equals("192.168.0.0/24"))
def test_get(self):
user = factory.make_User()
handler = SpaceHandler(user, {}, None)
space = factory.make_Space()
for _ in range(3):
node = factory.make_Node(interface=True)
interface = node.get_boot_interface()
subnet = factory.make_Subnet(space=space, vlan=interface.vlan)
factory.make_StaticIPAddress(subnet=subnet, interface=interface)
self.assertEqual(self.dehydrate_space(space),
handler.get({"id": space.id}))
def make_example_configuration(self):
# Configure example time references.
ntp_servers = {factory.make_name("ntp-server") for _ in range(5)}
Config.objects.set_config("ntp_servers", " ".join(ntp_servers))
# Populate the database with example peers.
space = factory.make_Space()
region, addr4, addr6 = make_region_with_address(space)
self.useFixture(MAASIDFixture(region.system_id))
peer1, addr1_4, addr1_6 = make_region_with_address(space)
peer2, addr2_4, addr2_6 = make_region_with_address(space)
# Return the servers and all possible peer IP addresses.
return ntp_servers, {addr1_4.ip, addr1_6.ip, addr2_4.ip, addr2_6.ip}
def test__rejects_provided_space_on_update(self):
space = factory.make_Space()
subnet = factory.make_Subnet()
form = SubnetForm(instance=subnet, data={"space": space.id})
self.assertFalse(form.is_valid(), dict(form.errors))
self.assertEqual(
{
"space": [
"Spaces may no longer be set on subnets. Set the space on the "
"underlying VLAN."
]
}, dict(form.errors))
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, if1, sn1, sip1 = self.make_node_with_address(network1, space1)
node2, if2, sn2, sip2 = self.make_node_with_address(network2, space2)
# 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 spaces 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, space1.id, 0),
(*right, *right, space2.id, 0),
]
with connection.cursor() as cursor:
cursor.execute("SELECT * from maasserver_routable_pairs")
self.assertItemsEqual(expected, cursor.fetchall())
def test__update_as_admin_succeeds_even_with_a_specified_space(self):
user = factory.make_admin()
handler = SubnetHandler(user, {})
subnet = factory.make_Subnet(description="sad subnet")
space = factory.make_Space()
new_description = "happy subnet"
handler.update({
"id": subnet.id,
"space": space.id,
"description": new_description
})
subnet = reload_object(subnet)
self.assertThat(subnet.description, Equals(new_description))
def test_get(self):
user = factory.make_User()
handler = VLANHandler(user, {}, None)
vlan = factory.make_VLAN(space=factory.make_Space())
for _ in range(3):
factory.make_Subnet(vlan=vlan)
for _ in range(3):
node = factory.make_Node(interface=True)
interface = node.get_boot_interface()
interface.vlan = vlan
interface.save()
self.assertEqual(self.dehydrate_vlan(vlan),
handler.get({"id": vlan.id}))
def test_list_constant_queries(self):
user = factory.make_User()
handler = SpaceHandler(user, {}, None)
for _ in range(10):
space = factory.make_Space()
node = factory.make_Node(interface=True)
interface = node.get_boot_interface()
subnet = factory.make_Subnet(space=space, vlan=interface.vlan)
factory.make_StaticIPAddress(subnet=subnet, interface=interface)
queries_one, _ = count_queries(handler.list, {"limit": 1})
queries_multiple, _ = count_queries(handler.list, {})
self.assertEqual(queries_one, queries_multiple)
def test__updates_space(self):
new_name = factory.make_name("space")
new_description = factory.make_name("description")
space = factory.make_Space()
form = SpaceForm(instance=space,
data={
"name": new_name,
"description": new_description,
})
self.assertTrue(form.is_valid(), form.errors)
form.save()
self.assertEqual(new_name, reload_object(space).name)
self.assertEqual(new_description, reload_object(space).description)
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_update(self):
self.become_admin()
space = factory.make_Space()
new_name = factory.make_name("space")
uri = get_space_uri(space)
response = self.client.put(uri, {"name": new_name})
self.assertEqual(http.client.OK, response.status_code,
response.content)
self.assertEqual(
new_name,
json.loads(response.content.decode(
settings.DEFAULT_CHARSET))["name"],
)
self.assertEqual(new_name, reload_object(space).name)
def test__rejects_space_on_create(self):
space = factory.make_Space()
form = SubnetForm({
"space": space.id,
"cidr": factory._make_random_network()
})
self.assertFalse(form.is_valid(), dict(form.errors))
self.assertEqual(
{
"space": [
"Spaces may no longer be set on subnets. Set the space on the "
"underlying VLAN."
]
}, dict(form.errors))
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_read_with_no_undefined_space(self):
factory.make_VLAN()
space = factory.make_Space()
uri = get_spaces_uri()
fill_empty_spaces(space)
response = self.client.get(uri)
self.assertEqual(http.client.OK, response.status_code,
response.content)
# Does not include the undefined space.
expected_ids = [space.id]
result_ids = [
space["id"] for space in json.loads(
response.content.decode(settings.DEFAULT_CHARSET))
]
self.assertItemsEqual(expected_ids, result_ids)
def test__getConfiguration_returns_configuration_object(self):
service = syslog.RegionSyslogService(reactor)
# Put all addresses in the same space so they're mutually routable.
space = factory.make_Space()
# Populate the database with "this" region rack and an example peer.
region_rack, _, _ = make_region_rack_with_address(space)
self.useFixture(MAASIDFixture(region_rack.system_id))
peer, addr4, addr6 = make_region_rack_with_address(space)
observed = service._getConfiguration()
self.assertThat(observed, IsInstance(syslog._Configuration))
expected_peers = AllMatch(Equals((peer.hostname, IPAddress(addr4.ip))))
self.assertThat(observed, MatchesStructure(peers=expected_peers))
def make_example_configuration(self):
# Set the syslog port.
port = factory.pick_port()
Config.objects.set_config('maas_syslog_port', port)
# Populate the database with example peers.
space = factory.make_Space()
region, addr4, addr6 = make_region_rack_with_address(space)
self.useFixture(MAASIDFixture(region.system_id))
peer1, addr1_4, addr1_6 = make_region_rack_with_address(space)
peer2, addr2_4, addr2_6 = make_region_rack_with_address(space)
# Return the servers and all possible peer IP addresses.
return port, [
(peer1, sorted([IPAddress(addr1_4.ip),
IPAddress(addr1_6.ip)])[0]),
(peer2, sorted([IPAddress(addr2_4.ip),
IPAddress(addr2_6.ip)])[0]),
]
def test_includes_vlan_objects(self):
space = factory.make_Space()
vlan = factory.make_VLAN(space=space)
uri = get_space_uri(space)
response = self.client.get(uri)
self.assertEqual(http.client.OK, response.status_code,
response.content)
parsed_space = json.loads(
response.content.decode(settings.DEFAULT_CHARSET))
parsed_vlan = parsed_space['vlans'][0]
self.assertThat(
parsed_vlan,
ContainsDict({
"id": Equals(vlan.id),
"vid": Equals(vlan.vid),
"fabric_id": Equals(vlan.fabric_id),
}))
def test_read(self):
space = factory.make_Space()
subnet_ids = [factory.make_Subnet(space=space).id for _ in range(3)]
uri = get_space_uri(space)
response = self.client.get(uri)
self.assertEqual(http.client.OK, response.status_code,
response.content)
parsed_space = json.loads(
response.content.decode(settings.DEFAULT_CHARSET))
self.assertThat(
parsed_space,
ContainsDict({
"id": Equals(space.id),
"name": Equals(space.get_name()),
}))
parsed_subnets = [subnet["id"] for subnet in parsed_space["subnets"]]
self.assertItemsEqual(subnet_ids, parsed_subnets)