test: check all logger level case variants

Add unit test to cover all cases of LevelFilter.

Signed-off-by: Jonathan Woollett-Light <jcawl@amazon.co.uk>
Signed-off-by: Sudan Landge <sudanl@amazon.com>

src/vmm/Cargo.toml

@@ -50,6 +50,7 @@ vm-fdt = "0.2.0"
 criterion = { version = "0.5.0", default-features = false }
 device_tree = "1.1.0"
 proptest = { version = "1.0.0", default-features = false, features = ["std"] }
+itertools = "0.12.0"
 
 [features]
 tracing = ["log-instrument"]

src/vmm/src/logger/logging.rs

@@ -10,9 +10,10 @@ use std::sync::{Mutex, OnceLock};
 use std::thread;
 
 use log::{Log, Metadata, Record};
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize};
 use utils::time::LocalTime;
 
+// use serde::de::IntoDeserializer;
 use super::metrics::{IncMetric, METRICS};
 
 /// Default level filter for logger matching the swagger specification
@@ -200,7 +201,10 @@ pub struct LoggerConfig {
 /// the log level filter. It would be a breaking change to no longer support this. In the next
 /// breaking release this should be removed (replaced with `log::LevelFilter` and only supporting
 /// its default deserialization).
-#[derive(Clone, Debug, PartialEq, Eq, Deserialize, Serialize)]
+// #[serde(rename_all = "lowercase")]
+#[derive(Clone, Debug, PartialEq, Eq, Serialize)]
+#[serde(rename_all(deserialize = "lowercase"))]
+// #[serde(remote = "LevelFilter")]
 pub enum LevelFilter {
     /// [`log::LevelFilter:Off`]
     #[serde(alias = "OFF")]
@@ -233,6 +237,28 @@ impl From<LevelFilter> for log::LevelFilter {
         }
     }
 }
+impl<'de> Deserialize<'de> for LevelFilter {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        use serde::de::Error;
+        use serde_json::Map;
+        let map = Map::<String, _>::deserialize(deserializer)?;
+        for key in map.keys() {
+            return match key.to_lowercase().as_str() {
+                "off" => Ok(LevelFilter::Off),
+                "trace" => Ok(LevelFilter::Trace),
+                "debug" => Ok(LevelFilter::Debug),
+                "info" => Ok(LevelFilter::Info),
+                "warn" | "warning" => Ok(LevelFilter::Warn),
+                "error" => Ok(LevelFilter::Error),
+                _ => Err(D::Error::custom("Invalid LevelFilter")),
+            };
+        }
+        Err(D::Error::custom("Could not deserialize"))
+    }
+}
 
 /// Error type for [`<LevelFilter as FromStr>::from_str`].
 #[derive(Debug, PartialEq, Eq, thiserror::Error)]
@@ -288,6 +314,30 @@ mod tests {
         );
     }
     #[test]
+    fn levelfilter_from_str_all_variants() {
+        use itertools::Itertools;
+
+        for level in ["off", "trace", "debug", "info", "warn", "warning", "error"] {
+            let multi = level.chars().map(|_| 0..=1).multi_cartesian_product();
+            for combination in multi {
+                let variant = level
+                    .chars()
+                    .zip_eq(combination)
+                    .map(|(c, v)| match v {
+                        0 => c.to_ascii_lowercase(),
+                        1 => c.to_ascii_uppercase(),
+                        _ => unreachable!(),
+                    })
+                    .collect::<String>();
+
+                // to deserialize with serde_json we need json string in this format: {"Unit":0}
+                let ex = format!("{} \"{}\": \"{}\" {}", "{", variant, "0", "}");
+                assert!(LevelFilter::from_str(&variant).is_ok(), "{variant}");
+                assert!(serde_json::from_str::<LevelFilter>(&ex).is_ok(), "{ex}");
+            }
+        }
+    }
+    #[test]
     fn levelfilter_from_str() {
         assert_eq!(
             LevelFilter::from_str("bad"),