def test_does_not_fail_if_cannot_find_subnet(self):
rack = factory.make_RackController()
iface = factory.make_Interface(node=rack)
factory.make_Discovery(interface=iface, ip="10.0.0.1")
self.assertThat(Discovery.objects.first().subnet, Is(None))
def test___populates_power_type_initial(self):
rack = factory.make_RackController()
form = ControllerForm(instance=rack)
self.assertEqual(rack.power_type, form.fields['power_type'].initial)
def test_compose_enlistment_preseed(self):
rack_controller = factory.make_RackController()
url = factory.make_simple_http_url()
request = make_HttpRequest()
apt_proxy = get_apt_proxy(request, rack_controller)
preseed = yaml.safe_load(
compose_enlistment_preseed(request, rack_controller, {
'metadata_enlist_url': url,
'syslog_host_port': url,
}))
self.assertDictEqual({'MAAS': {
'metadata_url': url
}}, preseed['datasource'])
self.assertTrue(preseed['manage_etc_hosts'])
self.assertDictEqual({'remotes': {'maas': url}}, preseed['rsyslog'])
self.assertDictEqual(
{
'delay': 'now',
'mode': 'poweroff',
'timeout': 1800,
'condition': 'test ! -e /tmp/block-poweroff',
}, preseed['power_state'])
self.assertItemsEqual([
'python3-yaml', 'python3-oauthlib', 'freeipmi-tools', 'ipmitool',
'sshpass', 'archdetect-deb', 'jq'
], preseed['packages'])
default = PackageRepository.get_main_archive().url
ports = PackageRepository.get_ports_archive().url
self.assertThat(
preseed,
ContainsDict({
'apt':
ContainsDict({
'preserve_sources_list':
Equals(False),
'primary':
MatchesListwise([
MatchesDict({
"arches": Equals(["amd64", "i386"]),
"uri": Equals(default),
}),
MatchesDict({
"arches": Equals(["default"]),
"uri": Equals(ports),
}),
]),
'proxy':
Equals(apt_proxy),
'security':
MatchesListwise([
MatchesDict({
"arches": Equals(["amd64", "i386"]),
"uri": Equals(default),
}),
MatchesDict({
"arches": Equals(["default"]),
"uri": Equals(ports),
}),
]),
})
}))
def test_creates_services_for_rack_controller(self):
rack_controller = factory.make_RackController()
services = Service.objects.filter(node=rack_controller)
self.assertThat({service.name
for service in services}, Equals(RACK_SERVICES))
def test_controllerinfo_set_version(self):
controller = factory.make_RackController()
ControllerInfo.objects.set_version(controller, "2.3.0")
self.assertThat(controller.version, Equals("2.3.0"))
def make_controllers(self, number):
"""Create `number` of new nodes."""
for counter in range(number):
factory.make_RackController()
def test_update_verfies_secondary_rack_is_on_vlan(self):
vlan = factory.make_VLAN()
rack = factory.make_RackController()
form = VLANForm(instance=vlan, data={"secondary_rack": rack.system_id})
self.assertFalse(form.is_valid(), form.errors)
def test_requires_admin_permission(self):
user = factory.make_User()
rack = factory.make_RackController()
self.assertFalse(ImportImages(rack, user).is_permitted())
def test_delete_action_last_for_controller(self):
controller = factory.make_RackController()
actions = compile_node_actions(
controller, factory.make_admin(), classes=ACTION_CLASSES)
self.assertEqual('delete', list(actions)[-1])
def test_scope_versions_other(self):
rack = factory.make_RackController()
update_state(rack.system_id, "versions", {"something": "else"})
# no ControllerInfo is created as the state is not updated
self.assertFalse(hasattr(rack, "controllerinfo"))
def test_scope_unhandled(self):
rack = factory.make_RackController()
self.assertRaises(NoSuchScope, update_state, rack.system_id, "other",
{})
def create_rack_controller(self, **kwargs):
rack = factory.make_RackController(**kwargs)
return rack
def create_rack_interface(self):
rack_controller = factory.make_RackController(interface=False)
interface = factory.make_Interface(INTERFACE_TYPE.PHYSICAL,
node=rack_controller)
return rack_controller, interface
def test_associates_known_subnet(self):
rack = factory.make_RackController()
iface = factory.make_Interface(node=rack)
subnet = factory.make_Subnet(cidr="10.0.0.0/8", vlan=iface.vlan)
factory.make_Discovery(interface=iface, ip="10.0.0.1")
self.assertThat(Discovery.objects.first().subnet, Equals(subnet))
def test_returns_False_with_one_cluster(self):
factory.make_RackController()
key = factory.make_name("invalid-key")
self.useFixture(RunningClusterRPCFixture())
is_valid = validate_license_key("windows", "win2012", key)
self.assertFalse(is_valid)
def test__updates_last_image_sync(self):
rack = factory.make_RackController()
update_last_image_sync(rack.system_id)
self.assertEqual(now(), reload_object(rack).last_image_sync)
def test_dehydrate_show_os_info_returns_true(self):
owner = factory.make_admin()
rack = factory.make_RackController()
handler = ControllerHandler(owner, {}, None)
self.assertTrue(handler.dehydrate_show_os_info(rack))
def test__integrates_with_get_maas_facing_server_host(self):
ip = factory.make_ipv4_address()
maas_url = "http://%s" % ip
rack = factory.make_RackController(url=maas_url)
self.assertEqual(str(ip),
server_address.get_maas_facing_server_host(rack))
def test_get_maas_stats(self):
# Make one component of everything
factory.make_RegionRackController()
factory.make_RegionController()
factory.make_RackController()
factory.make_Machine(cpu_count=2, memory=200, status=4)
factory.make_Machine(cpu_count=3, memory=100, status=11)
factory.make_Device()
subnets = Subnet.objects.all()
v4 = [net for net in subnets if net.get_ip_version() == 4]
v6 = [net for net in subnets if net.get_ip_version() == 6]
stats = get_maas_stats()
machine_stats = get_machine_stats()
# Due to floating point calculation subtleties, sometimes the value the
# database returns is off by one compared to the value Python
# calculates, so just get it directly from the database for the test.
total_storage = machine_stats['total_storage']
node_status = Node.objects.values_list('status', flat=True)
node_status = Counter(node_status)
compare = {
"controllers": {
"regionracks": 1,
"regions": 1,
"racks": 1,
},
"nodes": {
"machines": 2,
"devices": 1,
},
"machine_stats": {
"total_cpu": 5,
"total_mem": 300,
"total_storage": total_storage,
},
"machine_status": {
"new":
node_status.get(NODE_STATUS.NEW, 0),
"ready":
node_status.get(NODE_STATUS.READY, 0),
"allocated":
node_status.get(NODE_STATUS.ALLOCATED, 0),
"deployed":
node_status.get(NODE_STATUS.DEPLOYED, 0),
"commissioning":
node_status.get(NODE_STATUS.COMMISSIONING, 0),
"testing":
node_status.get(NODE_STATUS.TESTING, 0),
"deploying":
node_status.get(NODE_STATUS.DEPLOYING, 0),
"failed_deployment":
node_status.get(NODE_STATUS.FAILED_DEPLOYMENT, 0),
"failed_commissioning":
node_status.get(NODE_STATUS.COMMISSIONING, 0),
"failed_testing":
node_status.get(NODE_STATUS.FAILED_TESTING, 0),
"broken":
node_status.get(NODE_STATUS.BROKEN, 0),
},
"network_stats": {
"spaces": Space.objects.count(),
"fabrics": Fabric.objects.count(),
"vlans": VLAN.objects.count(),
"subnets_v4": len(v4),
"subnets_v6": len(v6),
},
}
self.assertEquals(stats, json.dumps(compare))
def test_get_maas_facing_server_host_returns_rack_maas_url(self):
hostname = factory.make_hostname()
maas_url = "http://%s" % hostname
rack = factory.make_RackController(url=maas_url)
self.assertEqual(hostname,
server_address.get_maas_facing_server_host(rack))
def test_PUT_requires_admin(self):
rack = factory.make_RackController(owner=self.user)
response = self.client.put(self.get_rack_uri(rack), {})
self.assertEqual(http.client.FORBIDDEN, response.status_code)
def test_compose_enlistment_preseed(self):
rack_controller = factory.make_RackController()
url = factory.make_simple_http_url()
request = make_HttpRequest()
apt_proxy = get_apt_proxy(request, rack_controller)
preseed = yaml.safe_load(
compose_enlistment_preseed(
request,
rack_controller,
{"syslog_host_port": url},
))
self.assertDictEqual(
{
"MAAS": {
"metadata_url": request.build_absolute_uri(
reverse("metadata"))
}
},
preseed["datasource"],
)
self.assertTrue(preseed["manage_etc_hosts"])
self.assertDictEqual({"remotes": {"maas": url}}, preseed["rsyslog"])
self.assertDictEqual(
{
"delay": "now",
"mode": "poweroff",
"timeout": 1800,
"condition": "test ! -e /tmp/block-poweroff",
},
preseed["power_state"],
)
self.assertItemsEqual(
[
"python3-yaml",
"python3-oauthlib",
],
preseed["packages"],
)
default = PackageRepository.get_main_archive().url
ports = PackageRepository.get_ports_archive().url
self.assertThat(
preseed,
ContainsDict({
"apt":
ContainsDict({
"preserve_sources_list":
Equals(False),
"primary":
MatchesListwise([
MatchesDict({
"arches": Equals(["amd64", "i386"]),
"uri": Equals(default),
}),
MatchesDict({
"arches": Equals(["default"]),
"uri": Equals(ports),
}),
]),
"proxy":
Equals(apt_proxy),
"security":
MatchesListwise([
MatchesDict({
"arches": Equals(["amd64", "i386"]),
"uri": Equals(default),
}),
MatchesDict({
"arches": Equals(["default"]),
"uri": Equals(ports),
}),
]),
})
}),
)
def test_str(self):
controller = factory.make_RackController(hostname="foobar")
info, _ = ControllerInfo.objects.update_or_create(node=controller)
self.assertEqual("ControllerInfo (foobar)", str(info))
def test_get_maas_stats(self):
# Make one component of everything
factory.make_RegionRackController()
factory.make_RegionController()
factory.make_RackController()
factory.make_Machine(cpu_count=2, memory=200, status=NODE_STATUS.READY)
factory.make_Machine(status=NODE_STATUS.READY)
factory.make_Machine(status=NODE_STATUS.NEW)
for _ in range(4):
factory.make_Machine(status=NODE_STATUS.ALLOCATED)
factory.make_Machine(cpu_count=3,
memory=100,
status=NODE_STATUS.FAILED_DEPLOYMENT)
for _ in range(2):
factory.make_Machine(status=NODE_STATUS.DEPLOYED)
factory.make_Device()
factory.make_Device()
subnets = Subnet.objects.all()
v4 = [net for net in subnets if net.get_ip_version() == 4]
v6 = [net for net in subnets if net.get_ip_version() == 6]
stats = get_maas_stats()
machine_stats = get_machine_stats()
# Due to floating point calculation subtleties, sometimes the value the
# database returns is off by one compared to the value Python
# calculates, so just get it directly from the database for the test.
total_storage = machine_stats["total_storage"]
expected = {
"controllers": {
"regionracks": 1,
"regions": 1,
"racks": 1
},
"nodes": {
"machines": 10,
"devices": 2
},
"machine_stats": {
"total_cpu": 5,
"total_mem": 300,
"total_storage": total_storage,
},
"machine_status": {
"new": 1,
"ready": 2,
"allocated": 4,
"deployed": 2,
"commissioning": 0,
"testing": 0,
"deploying": 0,
"failed_deployment": 1,
"failed_commissioning": 0,
"failed_testing": 0,
"broken": 0,
},
"network_stats": {
"spaces": Space.objects.count(),
"fabrics": Fabric.objects.count(),
"vlans": VLAN.objects.count(),
"subnets_v4": len(v4),
"subnets_v6": len(v6),
},
}
self.assertEquals(json.loads(stats), expected)
def test_connected_rack_controllers(self):
vlan = factory.make_VLAN()
racks = [factory.make_RackController(vlan=vlan) for _ in range(3)]
self.assertItemsEqual(racks, vlan.connected_rack_controllers())
def test_calls_create_services_for_on_all_racks_on_delete(self):
rack_controllers = [factory.make_RackController() for _ in range(3)]
process = factory.make_RegionControllerProcess()
mock_create_for = self.patch(Service.objects, "create_services_for")
process.delete()
self.assertEqual(len(rack_controllers), mock_create_for.call_count)
def test_doesnt_fail_if_interface_missing(self):
rack_controller = factory.make_RackController()
# No error should be raised.
update_foreign_dhcp(rack_controller.system_id,
factory.make_name("eth"), None)
def test_notification_is_old(self):
ControllerInfo.objects.set_version(
factory.make_RackController(),
"2.9.0",
)
self.assertFalse(release_notifications.notification_available("2.8.0"))
def create_rack_controller(self, params=None):
if params is None:
params = {}
return factory.make_RackController(**params)
def test_dehydrate_empty_versions(self):
owner = factory.make_admin()
handler = ControllerHandler(owner, {}, None)
factory.make_RackController()
result = handler.list({})
self.assertEqual(result[0]["versions"], {})
