def test_compose_pinned_cores(self): user = yield deferToDatabase(factory.make_admin) handler = PodHandler(user, {}, None) pod = yield deferToDatabase(self.make_pod_with_hints) # Mock the RPC client. client = MagicMock() mock_getClient = self.patch(pods, "getClientFromIdentifiers") mock_getClient.return_value = succeed(client) # Mock the result of the composed machine. node = yield deferToDatabase(factory.make_Node) orig_init = ComposeMachineForm.__init__ def wrapped_init(obj, *args, **kwargs): self.form = obj return orig_init(obj, *args, **kwargs) self.patch(ComposeMachineForm, "__init__", wrapped_init) mock_compose_machine = self.patch(ComposeMachineForm, "compose") mock_compose_machine.return_value = succeed(node) yield handler.compose({ "id": pod.id, "skip_commissioning": True, "pinned_cores": [1, 2, 4], }) self.assertEqual(self.form.get_value_for("pinned_cores"), [1, 2, 4])
def test_get_permissions(self): admin = factory.make_admin() handler = PodHandler(admin, {}, None) pod = self.make_pod_with_hints() result = handler.full_dehydrate(pod) self.assertItemsEqual(['edit', 'delete', 'compose'], result['permissions'])
def test_get_permissions(self): admin = factory.make_admin() handler = PodHandler(admin, {}, None) pod = self.make_pod_with_hints() result = handler.full_dehydrate(pod) self.assertItemsEqual(["edit", "delete", "compose"], result["permissions"])
def test_list(self): admin = factory.make_admin() handler = PodHandler(admin, {}, None) pod = self.make_pod_with_hints() expected_data = [handler.full_dehydrate(pod, for_list=True)] result = handler.list({"id": pod.id}) self.assertThat(result, Equals(expected_data))
def test_get(self): admin = factory.make_admin() handler = PodHandler(admin, {}) pod = self.make_pod_with_hints() expected_data = self.dehydrate_pod(pod) result = handler.get({"id": pod.id}) self.assertThat(result, Equals(expected_data))
def test_full_dehydrate_for_list_no_details(self): admin = factory.make_admin() handler = PodHandler(admin, {}, None) vlan = factory.make_VLAN(dhcp_on=True) subnet = factory.make_Subnet(vlan=vlan) node = factory.make_Node_with_Interface_on_Subnet(subnet=subnet) ip = factory.make_StaticIPAddress(interface=node.boot_interface, subnet=subnet) numa_node0 = node.default_numanode numa_node0.cores = [0, 3] numa_node0.memory = 4096 numa_node0.save() factory.make_NUMANode(node=node, cores=[1, 4], memory=1024) factory.make_NUMANode(node=node, cores=[2, 5], memory=2048) project = factory.make_string() pod = self.make_pod_with_hints( pod_type="lxd", parameters={"project": project}, host=node, ip_address=ip, ) factory.make_VirtualMachine(bmc=pod, project=project) result = handler.full_dehydrate(pod, for_list=True) self.assertEqual(result["resources"]["numa"], []) self.assertEqual(result["resources"]["vms"], [])
def test_create(self): user = yield deferToDatabase(factory.make_admin) handler = PodHandler(user, {}) pod_info = self.make_pod_info() yield deferToDatabase(self.fake_pod_discovery) created_pod = yield handler.create(pod_info) self.assertIsNotNone(created_pod['id'])
def test_get_as_standard_user(self): user = factory.make_User() handler = PodHandler(user, {}, None) pod = self.make_pod_with_hints() expected_data = handler.full_dehydrate(pod) result = handler.get({"id": pod.id}) self.assertThat(result, Equals(expected_data))
def test_delete(self): user = yield deferToDatabase(factory.make_admin) handler = PodHandler(user, {}, None) pod = yield deferToDatabase(self.make_pod_with_hints) yield handler.delete({"id": pod.id}) expected_pod = yield deferToDatabase(reload_object, pod) self.assertIsNone(expected_pod)
def test_delete_decompose(self): user = yield deferToDatabase(factory.make_admin) handler = PodHandler(user, {}, None) pod = yield deferToDatabase(self.make_pod_with_hints) mock_async_delete = self.patch(Pod, "async_delete") yield deferToDatabase(factory.make_Machine, bmc=pod) yield handler.delete({"id": pod.id, "decompose": True}) mock_async_delete.assert_called_once_with(decompose=True)
def test_create(self): user = yield deferToDatabase(factory.make_admin) handler = PodHandler(user, {}, None) zone = yield deferToDatabase(factory.make_Zone) pod_info = self.make_pod_info() pod_info["zone"] = zone.id yield deferToDatabase(self.fake_pod_discovery) created_pod = yield handler.create(pod_info) self.assertIsNotNone(created_pod["id"])
def test_create_with_pool(self): user = yield deferToDatabase(factory.make_admin) handler = PodHandler(user, {}, None) pool = yield deferToDatabase(factory.make_ResourcePool) pod_info = self.make_pod_info() pod_info["pool"] = pool.id yield deferToDatabase(self.fake_pod_discovery) created_pod = yield handler.create(pod_info) self.assertEqual(pool.id, created_pod["pool"])
def test_get(self): admin = factory.make_admin() handler = PodHandler(admin, {}) pod = self.make_pod_with_hints() expected_data = handler.full_dehydrate(pod) result = handler.get({"id": pod.id}) self.assertItemsEqual(expected_data.keys(), result.keys()) for key in expected_data: self.assertEqual(expected_data[key], result[key], key) self.assertThat(result, Equals(expected_data))
def test_refresh(self): user = yield deferToDatabase(factory.make_admin) handler = PodHandler(user, {}) pod = yield deferToDatabase(self.make_pod_with_hints) mock_discover_and_sync_pod = self.patch(PodForm, 'discover_and_sync_pod') mock_discover_and_sync_pod.return_value = succeed(pod) expected_data = yield deferToDatabase(self.dehydrate_pod, pod) observed_data = yield handler.refresh({"id": pod.id}) self.assertThat(mock_discover_and_sync_pod, MockCalledOnceWith()) self.assertEqual(expected_data, observed_data)
def test_update(self): user = yield deferToDatabase(factory.make_admin) handler = PodHandler(user, {}) pod_info = self.make_pod_info() pod = yield deferToDatabase( factory.make_Pod, pod_type=pod_info['type']) pod_info['id'] = pod.id pod_info['name'] = factory.make_name('pod') yield deferToDatabase(self.fake_pod_discovery) updated_pod = yield handler.update(pod_info) self.assertEqual(pod_info['name'], updated_pod['name'])
def test_update(self): user = yield deferToDatabase(factory.make_admin) handler = PodHandler(user, {}, None) zone = yield deferToDatabase(factory.make_Zone) pod_info = self.make_pod_info() pod_info["zone"] = zone.id pod = yield deferToDatabase(factory.make_Pod, pod_type=pod_info["type"]) pod_info["id"] = pod.id pod_info["name"] = factory.make_name("pod") yield deferToDatabase(self.fake_pod_discovery) updated_pod = yield handler.update(pod_info) self.assertEqual(pod_info["name"], updated_pod["name"])
def test_get_with_pod_host_no_storage_pools(self): admin = factory.make_admin() handler = PodHandler(admin, {}, None) node = factory.make_Node() pod = self.make_pod_with_hints( pod_type="lxd", host=node, ) pod.default_storage_pool = None pod.save() PodStoragePool.objects.all().delete() result = handler.get({"id": pod.id}) self.assertIsNone(result["default_storage_pool"]) self.assertEqual(result["storage_pools"], [])
def test_get_with_pod_host_no_vlan(self): admin = factory.make_admin() handler = PodHandler(admin, {}, None) node = factory.make_Node() pod = self.make_pod_with_hints( pod_type="lxd", host=node, ) # attach an unconnected interface to the node interface = factory.make_Interface(node=node) interface.vlan = None interface.save() result = handler.get({"id": pod.id}) self.assertEqual(result["attached_vlans"], [])
def test_get(self): admin = factory.make_admin() handler = PodHandler(admin, {}, None) pod = self.make_pod_with_hints() expected_data = handler.full_dehydrate(pod) result = handler.get({"id": pod.id}) self.assertItemsEqual(expected_data.keys(), result.keys()) for key in expected_data: self.assertEqual(expected_data[key], result[key], key) self.assertThat(result, Equals(expected_data)) self.assertThat(result["host"], Equals(None)) self.assertThat(result["attached_vlans"], Equals([])) self.assertThat(result["boot_vlans"], Equals([])) self.assertThat(result["storage_pools"], Equals(expected_data["storage_pools"]))
def test_refresh(self): user = yield deferToDatabase(factory.make_admin) handler = PodHandler(user, {}, None) pod = yield deferToDatabase(self.make_pod_with_hints) mock_discover_and_sync_pod = self.patch(PodForm, "discover_and_sync_pod") mock_discover_and_sync_pod.return_value = succeed(pod) expected_data = yield deferToDatabase(handler.full_dehydrate, pod, for_list=False) observed_data = yield handler.refresh({"id": pod.id}) self.assertThat(mock_discover_and_sync_pod, MockCalledOnceWith()) self.assertItemsEqual(expected_data.keys(), observed_data.keys()) for key in expected_data: self.assertEqual(expected_data[key], observed_data[key], key) self.assertEqual(expected_data, observed_data)
def test_get_with_pod_host_determines_vlan_boot_status(self): admin = factory.make_admin() handler = PodHandler(admin, {}, None) vlan = factory.make_VLAN(dhcp_on=False) subnet = factory.make_Subnet(vlan=vlan) node = factory.make_Node_with_Interface_on_Subnet(subnet=subnet) ip = factory.make_StaticIPAddress(interface=node.boot_interface, subnet=subnet) pod = self.make_pod_with_hints(ip_address=ip) expected_data = handler.full_dehydrate(pod) result = handler.get({"id": pod.id}) self.assertItemsEqual(expected_data.keys(), result.keys()) for key in expected_data: self.assertEqual(expected_data[key], result[key], key) self.assertThat(result, Equals(expected_data)) self.assertThat(result["attached_vlans"], Equals([subnet.vlan_id])) self.assertThat(result["boot_vlans"], Equals([]))
def test__compose(self): user = yield deferToDatabase(factory.make_admin) handler = PodHandler(user, {}, None) pod = yield deferToDatabase(self.make_pod_with_hints) # Mock the RPC client. client = MagicMock() mock_getClient = self.patch(pods, "getClientFromIdentifiers") mock_getClient.return_value = succeed(client) # Mock the result of the composed machine. node = yield deferToDatabase(factory.make_Node) mock_compose_machine = self.patch(ComposeMachineForm, "compose") mock_compose_machine.return_value = succeed(node) observed_data = yield handler.compose( {"id": pod.id, "skip_commissioning": True} ) self.assertEqual(pod.id, observed_data["id"])
def test_get_projects(self): user = yield deferToDatabase(factory.make_admin) handler = PodHandler(user, {}, None) params = { "type": "lxd", "power_address": "1.2.3.4", "project": "p1", "password": "******", } mock_discover_pod_projects = self.patch(pod, "discover_pod_projects") mock_discover_pod_projects.return_value = succeed(None) mock_get_best_discovered_result = self.patch( pod, "get_best_discovered_result") mock_get_best_discovered_result.return_value = succeed([ DiscoveredPodProject(name="foo", description="Project foo"), DiscoveredPodProject(name="bar", description="Project bar"), ]) projects = yield handler.get_projects(params) self.assertEqual( projects, [ { "name": "foo", "description": "Project foo" }, { "name": "bar", "description": "Project bar" }, ], ) mock_discover_pod_projects.assert_called_once_with( "lxd", { "power_address": "1.2.3.4", "project": "p1", "password": "******", }, ) mock_get_best_discovered_result.assert_called_once()
async def test_get_projects_with_password(self): rack_controller = await deferToDatabase(factory.make_RackController) protocol = await deferToThread(self.get_rack_rpc_protocol, rack_controller, DiscoverPodProjects) protocol.DiscoverPodProjects.return_value = succeed({ "projects": [ DiscoveredPodProject( name="foo", description="Project foo", ), DiscoveredPodProject( name="bar", description="Project bar", ), ] }) user = await deferToDatabase(factory.make_admin) handler = PodHandler(user, {}, None) params = { "type": "lxd", "power_address": "1.2.3.4", "project": "p1", "password": "******", "certificate": "mycert", "key": "mykey", } projects = await handler.execute("get_projects", params) self.assertEqual( projects, [ { "name": "foo", "description": "Project foo" }, { "name": "bar", "description": "Project bar" }, ], ) protocol.DiscoverPodProjects.assert_called_once_with( protocol, type="lxd", context={ "power_address": "1.2.3.4", "project": "p1", "password": "******", "certificate": "mycert", "key": "mykey", }, )
def test_get(self): admin = factory.make_admin() handler = PodHandler(admin, {}, None) pod = self.make_pod_with_hints() # Create machines to test owners_count factory.make_Node() factory.make_Node(bmc=pod) factory.make_Node(bmc=pod, owner=admin) factory.make_Node(bmc=pod, owner=factory.make_User()) expected_data = handler.full_dehydrate(pod) result = handler.get({"id": pod.id}) self.assertItemsEqual(expected_data.keys(), result.keys()) for key in expected_data: self.assertEqual(expected_data[key], result[key], key) self.assertThat(result, Equals(expected_data)) self.assertThat(result["host"], Equals(None)) self.assertThat(result["attached_vlans"], Equals([])) self.assertThat(result["boot_vlans"], Equals([])) self.assertThat(result["storage_pools"], Equals(expected_data["storage_pools"])) self.assertThat(result["owners_count"], Equals(2)) self.assertEqual(result["numa_pinning"], [])
def test_allowed_methods(self): handler = PodHandler(factory.make_admin(), {}, None) self.assertCountEqual( handler.Meta.allowed_methods, [ "list", "get", "create", "update", "delete", "set_active", "refresh", "compose", "get_projects", ], )
def test_get_host_interfaces_sriov(self): admin = factory.make_admin() handler = PodHandler(admin, {}, None) node = factory.make_Machine() numa_node0 = node.default_numanode numa_node1 = factory.make_NUMANode(node=node) iface1 = factory.make_Interface( INTERFACE_TYPE.PHYSICAL, name="eth0", numa_node=numa_node0, sriov_max_vf=8, ) iface2 = factory.make_Interface( INTERFACE_TYPE.PHYSICAL, name="eth1", numa_node=numa_node1, sriov_max_vf=16, ) pod = self.make_pod_with_hints( pod_type="lxd", host=node, ) vm_machine0 = factory.make_Node(system_id="vm0") factory.make_Interface( INTERFACE_TYPE.PHYSICAL, node=vm_machine0, mac_address="11:11:11:11:11:11", ) vm_machine1 = factory.make_Node(system_id="vm1") factory.make_Interface( INTERFACE_TYPE.PHYSICAL, node=vm_machine1, mac_address="aa:aa:aa:aa:aa:aa", ) factory.make_Interface( INTERFACE_TYPE.PHYSICAL, node=vm_machine1, mac_address="bb:bb:bb:bb:bb:bb", ) vm0 = factory.make_VirtualMachine( bmc=pod, machine=vm_machine0, ) VirtualMachineInterface.objects.create( vm=vm0, mac_address="11:11:11:11:11:11", host_interface=iface1, attachment_type=InterfaceAttachType.SRIOV, ) vm1 = factory.make_VirtualMachine(bmc=pod, machine=vm_machine1) VirtualMachineInterface.objects.create( vm=vm1, mac_address="aa:aa:aa:aa:aa:aa", host_interface=iface1, attachment_type=InterfaceAttachType.SRIOV, ) VirtualMachineInterface.objects.create( vm=vm1, mac_address="bb:bb:bb:bb:bb:bb", host_interface=iface2, attachment_type=InterfaceAttachType.SRIOV, ) result = handler.get({"id": pod.id}) numa1, numa2 = result["resources"]["numa"] self.assertCountEqual(numa1["interfaces"], [iface1.id]) self.assertCountEqual(numa2["interfaces"], [iface2.id]) self.assertCountEqual( result["resources"]["interfaces"], [ { "id": iface1.id, "name": "eth0", "numa_index": 0, "virtual_functions": { "allocated_tracked": 2, "allocated_other": 0, "free": 6, }, }, { "id": iface2.id, "name": "eth1", "numa_index": 1, "virtual_functions": { "allocated_tracked": 1, "allocated_other": 0, "free": 15, }, }, ], )
def test_get_host_interfaces_no_sriov(self): admin = factory.make_admin() handler = PodHandler(admin, {}, None) node = factory.make_Machine() numa_node0 = node.default_numanode numa_node1 = factory.make_NUMANode(node=node) iface1 = factory.make_Interface( INTERFACE_TYPE.PHYSICAL, name="eth0", numa_node=numa_node0 ) br1 = factory.make_Interface( INTERFACE_TYPE.BRIDGE, name="br0", numa_node=numa_node0, parents=[iface1], ) iface2 = factory.make_Interface( INTERFACE_TYPE.PHYSICAL, name="eth1", numa_node=numa_node1 ) pod = self.make_pod_with_hints( pod_type="lxd", host=node, ) vm_machine0 = factory.make_Node(system_id="vm0") factory.make_Interface( INTERFACE_TYPE.PHYSICAL, node=vm_machine0, mac_address="11:11:11:11:11:11", ) vm_machine1 = factory.make_Node(system_id="vm1") factory.make_Interface( INTERFACE_TYPE.PHYSICAL, node=vm_machine1, mac_address="aa:aa:aa:aa:aa:aa", ) factory.make_Interface( INTERFACE_TYPE.PHYSICAL, node=vm_machine1, mac_address="bb:bb:bb:bb:bb:bb", ) vm0 = factory.make_VirtualMachine( bmc=pod, machine=vm_machine0, ) VirtualMachineInterface.objects.create( vm=vm0, mac_address="11:11:11:11:11:11", host_interface=br1, attachment_type=InterfaceAttachType.BRIDGE, ) vm1 = factory.make_VirtualMachine(bmc=pod, machine=vm_machine1) VirtualMachineInterface.objects.create( vm=vm1, mac_address="aa:aa:aa:aa:aa:aa", host_interface=br1, attachment_type=InterfaceAttachType.BRIDGE, ) VirtualMachineInterface.objects.create( vm=vm1, mac_address="bb:bb:bb:bb:bb:bb", host_interface=iface2, attachment_type=InterfaceAttachType.MACVLAN, ) result = handler.get({"id": pod.id}) numa1, numa2 = result["numa_pinning"] self.assertEqual( [ { "id": iface1.id, "name": "eth0", "virtual_functions": {"allocated": 0, "free": 0}, }, { "id": br1.id, "name": "br0", "virtual_functions": {"allocated": 0, "free": 0}, }, ], numa1["interfaces"], ) self.assertEqual( [ [ { "guest_nic_id": None, "host_nic_id": br1.id, }, ], [ { "guest_nic_id": None, "host_nic_id": br1.id, }, ], ], [vm["networks"] for vm in numa1["vms"]], ) self.assertEqual( [ { "id": iface2.id, "name": "eth1", "virtual_functions": {"allocated": 0, "free": 0}, } ], numa2["interfaces"], ) self.assertEqual( [ [ { "guest_nic_id": None, "host_nic_id": iface2.id, }, ], ], [vm["networks"] for vm in numa2["vms"]], )
def test_get_with_pod_host(self): admin = factory.make_admin() handler = PodHandler(admin, {}, None) vlan = factory.make_VLAN(dhcp_on=True) subnet = factory.make_Subnet(vlan=vlan) node = factory.make_Node_with_Interface_on_Subnet(subnet=subnet) ip = factory.make_StaticIPAddress(interface=node.boot_interface, subnet=subnet) numa_node0 = node.default_numanode numa_node0.cores = [0, 3] numa_node0.memory = 4096 numa_node0.save() factory.make_NUMANode(node=node, cores=[1, 4], memory=1024) factory.make_NUMANode(node=node, cores=[2, 5], memory=2048) pod = self.make_pod_with_hints(pod_type="lxd", host=node, ip_address=ip) factory.make_VirtualMachine( memory=1024, pinned_cores=[0], hugepages_backed=False, bmc=pod, machine=factory.make_Node(system_id="vm0"), ) factory.make_VirtualMachine( memory=1024, pinned_cores=[2, 5], hugepages_backed=False, bmc=pod, machine=factory.make_Node(system_id="vm1"), ) expected_data = handler.full_dehydrate(pod) result = handler.get({"id": pod.id}) self.assertItemsEqual(expected_data.keys(), result.keys()) for key in expected_data: self.assertEqual(expected_data[key], result[key], key) self.assertThat(result, Equals(expected_data)) self.assertThat(result["host"], Equals(node.system_id)) self.assertThat(result["attached_vlans"], Equals([subnet.vlan_id])) self.assertThat(result["boot_vlans"], Equals([subnet.vlan_id])) self.assertEqual( result["numa_pinning"], [ { "cores": { "allocated": [0], "free": [3] }, "interfaces": [ { "id": 100, "name": "eth4", "virtual_functions": { "allocated": 4, "free": 12 }, }, { "id": 200, "name": "eth5", "virtual_functions": { "allocated": 14, "free": 2 }, }, ], "memory": { "general": { "allocated": 1024 * MB, "free": 3072 * MB }, "hugepages": [], }, "node_id": 0, "vms": [ { "pinned_cores": [0], "system_id": "vm0", "networks": [ { "guest_nic_id": 101, "host_nic_id": 100 }, { "guest_nic_id": 102, "host_nic_id": 100 }, ], }, ], }, { "cores": { "allocated": [], "free": [1, 4] }, "interfaces": [ { "id": 100, "name": "eth4", "virtual_functions": { "allocated": 4, "free": 12 }, }, { "id": 200, "name": "eth5", "virtual_functions": { "allocated": 14, "free": 2 }, }, ], "memory": { "general": { "allocated": 0, "free": 1024 * MB }, "hugepages": [], }, "node_id": 1, "vms": [], }, { "cores": { "allocated": [2, 5], "free": [] }, "interfaces": [ { "id": 100, "name": "eth4", "virtual_functions": { "allocated": 4, "free": 12 }, }, { "id": 200, "name": "eth5", "virtual_functions": { "allocated": 14, "free": 2 }, }, ], "memory": { "general": { "allocated": 1024 * MB, "free": 1024 * MB }, "hugepages": [], }, "node_id": 2, "vms": [ { "pinned_cores": [2, 5], "system_id": "vm1", "networks": [ { "guest_nic_id": 101, "host_nic_id": 100 }, { "guest_nic_id": 102, "host_nic_id": 100 }, ], }, ], }, ], )
def test_get_with_pod_host(self): admin = factory.make_admin() handler = PodHandler(admin, {}, None) vlan = factory.make_VLAN(dhcp_on=True) subnet = factory.make_Subnet(vlan=vlan) node = factory.make_Node_with_Interface_on_Subnet(subnet=subnet) ip = factory.make_StaticIPAddress(interface=node.boot_interface, subnet=subnet) numa_node0 = node.default_numanode numa_node0.cores = [0, 3] numa_node0.memory = 4096 numa_node0.save() factory.make_NUMANode(node=node, cores=[1, 4], memory=1024) factory.make_NUMANode(node=node, cores=[2, 5], memory=2048) project = factory.make_string() pod = self.make_pod_with_hints( pod_type="lxd", parameters={"project": project}, host=node, ip_address=ip, ) vm0 = factory.make_VirtualMachine( project=project, memory=1024, pinned_cores=[0], hugepages_backed=False, bmc=pod, machine=factory.make_Node(system_id="vm0"), ) vm1 = factory.make_VirtualMachine( project=project, memory=1024, pinned_cores=[2, 5], hugepages_backed=False, bmc=pod, machine=factory.make_Node(system_id="vm1"), ) expected_numa_details = [ { "cores": { "allocated": [0], "free": [3] }, "interfaces": [node.boot_interface.id], "memory": { "general": { "allocated": 1024 * MB, "free": 3072 * MB }, "hugepages": [], }, "node_id": 0, "vms": [vm0.id], }, { "cores": { "allocated": [], "free": [1, 4] }, "interfaces": [], "memory": { "general": { "allocated": 0, "free": 1024 * MB }, "hugepages": [], }, "node_id": 1, "vms": [], }, { "cores": { "allocated": [2, 5], "free": [] }, "interfaces": [], "memory": { "general": { "allocated": 1024 * MB, "free": 1024 * MB }, "hugepages": [], }, "node_id": 2, "vms": [vm1.id], }, ] result = handler.get({"id": pod.id}) self.assertThat(result["host"], Equals(node.system_id)) self.assertThat(result["attached_vlans"], Equals([subnet.vlan_id])) self.assertThat(result["boot_vlans"], Equals([subnet.vlan_id])) resources = result["resources"] self.assertEqual( resources["cores"], { "allocated_other": 0, "allocated_tracked": 3, "free": 3 }, ) self.assertEqual( resources["interfaces"], [{ "id": node.boot_interface.id, "name": node.boot_interface.name, "numa_index": 0, "virtual_functions": { "allocated_other": 0, "allocated_tracked": 0, "free": 0, }, }], ) self.assertEqual( resources["memory"], { "general": { "allocated_other": 0, "allocated_tracked": 2147483648, "free": 5368709120, }, "hugepages": { "allocated_other": 0, "allocated_tracked": 0, "free": 0, }, }, ) self.assertEqual(resources["numa"], expected_numa_details) self.assertEqual(resources["vm_count"], {"other": 0, "tracked": 2}) self.assertCountEqual( resources["vms"], [ { "id": vm0.id, "system_id": "vm0", "memory": 1024 * MB, "hugepages_backed": False, "pinned_cores": [0], "unpinned_cores": 0, }, { "id": vm1.id, "system_id": "vm1", "memory": 1024 * MB, "hugepages_backed": False, "pinned_cores": [2, 5], "unpinned_cores": 0, }, ], )