refactor(test): Move MachineConfig::update tests to machine_config.rs

There's no need to test this through VmResources when it can be tested
in isolation. Also, everytime I touch MachineConfig I get confsued by
where the hell the tests are, cuz not only are they in a different
module, they're also one directory level away. So move the tests into
machine_config.rs, where it makes sense to have them.

Signed-off-by: Patrick Roy <roypat@amazon.co.uk>

Author: roypat

src/vmm/src/resources.rs

@@ -1323,44 +1323,6 @@ mod tests {
             aux_vm_config
         );
 
-        // Invalid vcpu count.
-        aux_vm_config.vcpu_count = Some(0);
-        assert_eq!(
-            vm_resources.update_machine_config(&aux_vm_config),
-            Err(MachineConfigError::InvalidVcpuCount)
-        );
-        aux_vm_config.vcpu_count = Some(33);
-        assert_eq!(
-            vm_resources.update_machine_config(&aux_vm_config),
-            Err(MachineConfigError::InvalidVcpuCount)
-        );
-
-        // Check that SMT is not supported on aarch64, and that on x86_64 enabling it requires vcpu
-        // count to be even.
-        aux_vm_config.smt = Some(true);
-        #[cfg(target_arch = "aarch64")]
-        assert_eq!(
-            vm_resources.update_machine_config(&aux_vm_config),
-            Err(MachineConfigError::SmtNotSupported)
-        );
-        aux_vm_config.vcpu_count = Some(3);
-        #[cfg(target_arch = "x86_64")]
-        assert_eq!(
-            vm_resources.update_machine_config(&aux_vm_config),
-            Err(MachineConfigError::InvalidVcpuCount)
-        );
-        aux_vm_config.vcpu_count = Some(32);
-        #[cfg(target_arch = "x86_64")]
-        vm_resources.update_machine_config(&aux_vm_config).unwrap();
-        aux_vm_config.smt = Some(false);
-
-        // Invalid mem_size_mib.
-        aux_vm_config.mem_size_mib = Some(0);
-        assert_eq!(
-            vm_resources.update_machine_config(&aux_vm_config),
-            Err(MachineConfigError::InvalidMemorySize)
-        );
-
         // Incompatible mem_size_mib with balloon size.
         vm_resources.machine_config.mem_size_mib = 128;
         vm_resources
@@ -1379,23 +1341,6 @@ mod tests {
         // mem_size_mib compatible with balloon size.
         aux_vm_config.mem_size_mib = Some(256);
         vm_resources.update_machine_config(&aux_vm_config).unwrap();
-
-        // mem_size_mib incompatible with huge pages configuration
-        aux_vm_config.mem_size_mib = Some(129);
-        aux_vm_config.huge_pages = Some(HugePageConfig::Hugetlbfs2M);
-        assert_eq!(
-            vm_resources
-                .update_machine_config(&aux_vm_config)
-                .unwrap_err(),
-            MachineConfigError::InvalidMemorySize
-        );
-
-        // mem_size_mib compatible with huge page configuration
-        aux_vm_config.mem_size_mib = Some(2048);
-        // Remove the balloon device config that's added by `default_vm_resources` as it would
-        // trigger the "ballooning incompatible with huge pages" check.
-        vm_resources.balloon = BalloonBuilder::new();
-        vm_resources.update_machine_config(&aux_vm_config).unwrap();
     }
 
     #[test]

src/vmm/src/vmm_config/machine_config.rs

@@ -290,7 +290,100 @@ impl MachineConfig {
 #[cfg(test)]
 mod tests {
     use crate::cpu_config::templates::{CpuTemplateType, CustomCpuTemplate, StaticCpuTemplate};
-    use crate::vmm_config::machine_config::MachineConfig;
+    use crate::vmm_config::machine_config::{
+        HugePageConfig, MachineConfig, MachineConfigError, MachineConfigUpdate,
+    };
+
+    #[test]
+    #[allow(unused)] // some assertions exist only on specific architectures.
+    fn test_machine_config_update() {
+        let mconf = MachineConfig::default();
+
+        // Assert that the default machine config is valid
+        assert_eq!(
+            mconf
+                .update(&MachineConfigUpdate::from(mconf.clone()))
+                .unwrap(),
+            mconf
+        );
+
+        // Invalid vCPU counts
+        let res = mconf.update(&MachineConfigUpdate {
+            vcpu_count: Some(0),
+            ..Default::default()
+        });
+        assert_eq!(res, Err(MachineConfigError::InvalidVcpuCount));
+
+        let res = mconf.update(&MachineConfigUpdate {
+            vcpu_count: Some(33),
+            ..Default::default()
+        });
+        assert_eq!(res, Err(MachineConfigError::InvalidVcpuCount));
+
+        // Invalid memory size
+        let res = mconf.update(&MachineConfigUpdate {
+            mem_size_mib: Some(0),
+            ..Default::default()
+        });
+        assert_eq!(res, Err(MachineConfigError::InvalidMemorySize));
+
+        // Memory Size incompatible with huge page configuration
+        let res = mconf.update(&MachineConfigUpdate {
+            mem_size_mib: Some(31),
+            huge_pages: Some(HugePageConfig::Hugetlbfs2M),
+            ..Default::default()
+        });
+        assert_eq!(res, Err(MachineConfigError::InvalidMemorySize));
+
+        // works if the memory size is a multiple of huge page size indeed
+        let updated = mconf
+            .update(&MachineConfigUpdate {
+                mem_size_mib: Some(32),
+                huge_pages: Some(HugePageConfig::Hugetlbfs2M),
+                ..Default::default()
+            })
+            .unwrap();
+        assert_eq!(updated.huge_pages, HugePageConfig::Hugetlbfs2M);
+        assert_eq!(updated.mem_size_mib, 32);
+    }
+
+    #[test]
+    #[cfg(target_arch = "aarch64")]
+    fn test_machine_config_update_aarch64() {
+        let mconf = MachineConfig::default();
+
+        // Check that SMT is not supported on aarch64
+        let res = mconf.update(&MachineConfigUpdate {
+            smt: Some(true),
+            ..Default::default()
+        });
+        assert_eq!(res, Err(MachineConfigError::SmtNotSupported));
+    }
+
+    #[test]
+    #[cfg(target_arch = "x86_64")]
+    fn test_machine_config_update_x86_64() {
+        let mconf = MachineConfig::default();
+
+        // Test that SMT requires an even vcpu count
+        let res = mconf.update(&MachineConfigUpdate {
+            vcpu_count: Some(3),
+            smt: Some(true),
+            ..Default::default()
+        });
+        assert_eq!(res, Err(MachineConfigError::InvalidVcpuCount));
+
+        // Works if the vcpu count is even indeed
+        let updated = mconf
+            .update(&MachineConfigUpdate {
+                vcpu_count: Some(32),
+                smt: Some(true),
+                ..Default::default()
+            })
+            .unwrap();
+        assert_eq!(updated.vcpu_count, 32);
+        assert!(updated.smt);
+    }
 
     // Ensure the special (de)serialization logic for the cpu_template field works:
     // only static cpu templates can be specified via the machine-config endpoint, but