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>

Author: Sudan Landge

Cargo.lock

@@ -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/Cargo.toml

@@ -10,7 +10,7 @@ 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 super::metrics::{IncMetric, METRICS};
@@ -200,7 +200,7 @@ 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)]
+#[derive(Clone, Debug, PartialEq, Eq, Serialize)]
 pub enum LevelFilter {
     /// [`log::LevelFilter:Off`]
     #[serde(alias = "OFF")]
@@ -233,6 +233,25 @@ 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;
+        let key = String::deserialize(deserializer)?;
+        let level = 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")),
+        };
+        level
+    }
+}
 
 /// Error type for [`<LevelFilter as FromStr>::from_str`].
 #[derive(Debug, PartialEq, Eq, thiserror::Error)]
@@ -288,6 +307,34 @@ mod tests {
         );
     }
     #[test]
+    fn levelfilter_from_str_all_variants() {
+        use itertools::Itertools;
+
+        #[derive(Debug, Deserialize)]
+        struct Foo {
+            level: LevelFilter,
+        }
+
+        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>();
+
+                let ex = format!("{} \"level\": \"{}\" {}", "{", variant, "}");
+                assert!(LevelFilter::from_str(&variant).is_ok(), "{variant}");
+                assert!(serde_json::from_str::<Foo>(&ex).is_ok(), "{ex}");
+            }
+        }
+    }
+    #[test]
     fn levelfilter_from_str() {
         assert_eq!(
             LevelFilter::from_str("bad"),