Merge #7

7: Remove unwrap when env variables are wrong r=TheNeikos a=TheNeikos



Co-authored-by: Marcel Müller <[email protected]>

src/error.rs

@@ -6,6 +6,8 @@ pub enum EnvDeserializationError {
     UnsupportedValue,
     #[error("Tried to nest values while a simple value was expected")]
     InvalidNestedValues,
+    #[error("Invalid nesting detected for paths ending in: {:?}", .0)]
+    InvalidEnvNesting(Vec<String>),
 }
 
 impl serde::de::Error for EnvDeserializationError {

src/lib.rs

@@ -145,7 +145,7 @@ fn from_primitive<T: DeserializeOwned, I: Iterator<Item = (Key, String)>>(
     values: I,
 ) -> Result<T, error::EnvDeserializationError> {
     let deserializer =
-        Value::from_list(values.map(|(key, val)| (key, Value::Simple(val))).collect()).unwrap();
+        Value::from_list(values.map(|(key, val)| (key, Value::Simple(val))).collect())?;
     T::deserialize(deserializer)
 }
 

src/value.rs

@@ -14,15 +14,21 @@ pub(crate) enum Value {
 const SEPERATOR: &str = "__";
 
 impl Value {
-    fn insert_at(&mut self, path: &[&str], value: Value) -> Result<(), ()> {
+    fn insert_at(&mut self, path: &[&str], value: Value) -> Result<(), EnvDeserializationError> {
         match self {
-            Value::Simple(_) => Err(()),
+            Value::Simple(_) => Err(EnvDeserializationError::InvalidEnvNesting(
+                path.iter().map(|s| s.to_string()).collect(),
+            )),
             Value::Map(values) => {
                 let val = if let Some((_key, val)) =
                     values.iter_mut().find(|(key, _)| key.as_ref() == path[0])
                 {
                     match val {
-                        Value::Simple(_) => return Err(()),
+                        Value::Simple(_) => {
+                            return Err(EnvDeserializationError::InvalidEnvNesting(
+                                path.iter().map(|s| s.to_string()).collect(),
+                            ))
+                        }
                         Value::Map(_) => val,
                     }
                 } else {
@@ -37,7 +43,11 @@ impl Value {
                     val.insert_at(path, value)
                 } else {
                     match val {
-                        Value::Simple(_) => return Err(()),
+                        Value::Simple(_) => {
+                            return Err(EnvDeserializationError::InvalidEnvNesting(
+                                path.iter().map(|s| s.to_string()).collect(),
+                            ))
+                        }
                         Value::Map(values) => values.push((Key::new(path[0].to_string()), value)),
                     }
                     Ok(())
@@ -46,7 +56,7 @@ impl Value {
         }
     }
 
-    pub(crate) fn from_list(list: Vec<(Key, Value)>) -> Result<Value, ()> {
+    pub(crate) fn from_list(list: Vec<(Key, Value)>) -> Result<Value, EnvDeserializationError> {
         let mut base = Value::Map(vec![]);
 
         for (key, value) in list {

tests/failure.rs

@@ -0,0 +1,41 @@
+#![allow(dead_code)]
+use serde::Deserialize;
+
+#[derive(Deserialize, Debug)]
+struct Simple {
+    test: bool,
+}
+
+#[test]
+fn wrongly_nested_fields() {
+    let vars = [("test", "true"), ("test__bar", "true")];
+
+    for (key, val) in vars {
+        std::env::set_var(key, val);
+    }
+
+    let config: Result<Simple, _> = envious::from_env(envious::Prefix::None);
+
+    for (key, _) in vars {
+        std::env::remove_var(key);
+    }
+
+    println!("{:?}", config.unwrap_err());
+}
+
+#[test]
+fn wrongly_nested_prefixed_fields() {
+    let vars = [("PRE_test", "true"), ("PRE_test__bar", "true")];
+
+    for (key, val) in vars {
+        std::env::set_var(key, val);
+    }
+
+    let config: Result<Simple, _> = envious::from_env(envious::Prefix::Some("PRE_"));
+
+    for (key, _) in vars {
+        std::env::remove_var(key);
+    }
+
+    println!("{:?}", config.unwrap_err());
+}