test(error): Organize tests

Author: epage

tests/testsuite/errors.rs

@@ -5,7 +5,7 @@ use config::{Config, ConfigError, File, FileFormat, Map, Value};
 
 #[test]
 #[cfg(feature = "json")]
-fn test_error_path_index_bounds() {
+fn test_path_index_bounds() {
     let c = Config::builder()
         .add_source(File::from_str(
             r#"
@@ -28,7 +28,7 @@ fn test_error_path_index_bounds() {
 
 #[test]
 #[cfg(feature = "json")]
-fn test_error_path_index_negative_bounds() {
+fn test_path_index_negative_bounds() {
     let c = Config::builder()
         .add_source(File::from_str(
             r#"
@@ -51,7 +51,7 @@ fn test_error_path_index_negative_bounds() {
 
 #[test]
 #[cfg(feature = "json")]
-fn test_error_parse() {
+fn test_parse() {
     let res = Config::builder()
         .add_source(File::from_str(
             r#"
@@ -72,67 +72,47 @@ fn test_error_parse() {
 
 #[test]
 #[cfg(feature = "json")]
-fn test_error_type() {
-    let c = Config::builder()
-        .add_source(File::from_str(
-            r#"
-{
-  "boolean_s_parse": "fals"
-}
-"#,
-            FileFormat::Json,
-        ))
+fn test_root_not_table() {
+    let e = Config::builder()
+        .add_source(File::from_str(r#"false"#, FileFormat::Json))
         .build()
-        .unwrap();
-
-    let res = c.get::<bool>("boolean_s_parse");
-
-    assert!(res.is_err());
-    assert_data_eq!(
-        res.unwrap_err().to_string(),
-        str![[r#"invalid type: string "fals", expected a boolean for key `boolean_s_parse`"#]]
-    );
+        .unwrap_err();
+    match e {
+        ConfigError::FileParse { cause, .. } => assert_eq!(
+            "invalid type: boolean `false`, expected a map",
+            format!("{cause}")
+        ),
+        _ => panic!("Wrong error: {:?}", e),
+    }
 }
 
 #[test]
 #[cfg(feature = "json")]
-fn test_error_deser_whole() {
-    #[derive(Deserialize, Debug)]
-    struct Place {
-        #[allow(dead_code)]
-        name: usize, // is actually s string
-    }
-
-    #[derive(Deserialize, Debug)]
-    struct Output {
-        #[allow(dead_code)]
-        place: Place,
-    }
-
+fn test_get_invalid_type() {
     let c = Config::builder()
         .add_source(File::from_str(
             r#"
 {
-  "place": {
-    "name": "Torre di Pisa"
-  }
+  "boolean_s_parse": "fals"
 }
 "#,
             FileFormat::Json,
         ))
         .build()
         .unwrap();
 
-    let res = c.try_deserialize::<Output>();
+    let res = c.get::<bool>("boolean_s_parse");
+
+    assert!(res.is_err());
     assert_data_eq!(
         res.unwrap_err().to_string(),
-        str![[r#"invalid type: string "Torre di Pisa", expected an integer for key `place.name`"#]]
+        str![[r#"invalid type: string "fals", expected a boolean for key `boolean_s_parse`"#]]
     );
 }
 
 #[test]
 #[cfg(feature = "json")]
-fn test_error_type_detached() {
+fn test_get_bool_invalid_type() {
     let c = Config::builder()
         .add_source(File::from_str(
             r#"
@@ -145,43 +125,42 @@ fn test_error_type_detached() {
         .build()
         .unwrap();
 
-    let value = c.get::<Value>("boolean_s_parse").unwrap();
-    let res = value.try_deserialize::<bool>();
+    let res = c.get_bool("boolean_s_parse");
 
     assert!(res.is_err());
     assert_data_eq!(
         res.unwrap_err().to_string(),
-        str![[r#"invalid type: string "fals", expected a boolean"#]]
+        str![[r#"invalid type: string "fals", expected a boolean for key `boolean_s_parse`"#]]
     );
 }
 
 #[test]
 #[cfg(feature = "json")]
-fn test_error_type_get_bool() {
+fn test_get_table_invalid_type() {
     let c = Config::builder()
         .add_source(File::from_str(
             r#"
 {
-  "boolean_s_parse": "fals"
+  "debug": true
 }
 "#,
             FileFormat::Json,
         ))
         .build()
         .unwrap();
 
-    let res = c.get_bool("boolean_s_parse");
+    let res = c.get_table("debug");
 
     assert!(res.is_err());
     assert_data_eq!(
         res.unwrap_err().to_string(),
-        str![[r#"invalid type: string "fals", expected a boolean for key `boolean_s_parse`"#]]
+        str!["invalid type: boolean `true`, expected a map for key `debug`"]
     );
 }
 
 #[test]
 #[cfg(feature = "json")]
-fn test_error_type_get_table() {
+fn test_get_array_invalid_type() {
     let c = Config::builder()
         .add_source(File::from_str(
             r#"
@@ -194,41 +173,42 @@ fn test_error_type_get_table() {
         .build()
         .unwrap();
 
-    let res = c.get_table("debug");
+    let res = c.get_array("debug");
 
     assert!(res.is_err());
     assert_data_eq!(
         res.unwrap_err().to_string(),
-        str!["invalid type: boolean `true`, expected a map for key `debug`"]
+        str!["invalid type: boolean `true`, expected an array for key `debug`"]
     );
 }
 
 #[test]
 #[cfg(feature = "json")]
-fn test_error_type_get_array() {
+fn test_value_deserialize_invalid_type() {
     let c = Config::builder()
         .add_source(File::from_str(
             r#"
 {
-  "debug": true
+  "boolean_s_parse": "fals"
 }
 "#,
             FileFormat::Json,
         ))
         .build()
         .unwrap();
 
-    let res = c.get_array("debug");
+    let value = c.get::<Value>("boolean_s_parse").unwrap();
+    let res = value.try_deserialize::<bool>();
 
     assert!(res.is_err());
     assert_data_eq!(
         res.unwrap_err().to_string(),
-        str!["invalid type: boolean `true`, expected an array for key `debug`"]
+        str![[r#"invalid type: string "fals", expected a boolean"#]]
     );
 }
 
 #[test]
-fn test_error_enum_de() {
+fn test_value_deserialize_enum() {
     #[derive(Debug, Deserialize, PartialEq, Eq)]
     enum Diode {
         Off,
@@ -262,57 +242,45 @@ fn test_error_enum_de() {
 
 #[test]
 #[cfg(feature = "json")]
-fn error_with_path() {
-    #[derive(Debug, Deserialize)]
-    struct Inner {
+fn test_deserialize_invalid_type() {
+    #[derive(Deserialize, Debug)]
+    struct Place {
         #[allow(dead_code)]
-        test: i32,
+        name: usize, // is actually s string
     }
 
-    #[derive(Debug, Deserialize)]
-    struct Outer {
+    #[derive(Deserialize, Debug)]
+    struct Output {
         #[allow(dead_code)]
-        inner: Inner,
+        place: Place,
     }
-    const CFG: &str = r#"
+
+    let c = Config::builder()
+        .add_source(File::from_str(
+            r#"
 {
-  "inner": {
-    "test": "ABC"
+  "place": {
+    "name": "Torre di Pisa"
   }
 }
-"#;
-
-    let e = Config::builder()
-        .add_source(File::from_str(CFG, FileFormat::Json))
+"#,
+            FileFormat::Json,
+        ))
         .build()
-        .unwrap()
-        .try_deserialize::<Outer>()
-        .unwrap_err();
+        .unwrap();
 
+    let res = c.try_deserialize::<Output>();
+    let e = res.unwrap_err();
+    assert_data_eq!(
+        e.to_string(),
+        str![[r#"invalid type: string "Torre di Pisa", expected an integer for key `place.name`"#]]
+    );
     if let ConfigError::Type {
         key: Some(path), ..
     } = e
     {
-        assert_eq!(path, "inner.test");
+        assert_eq!(path, "place.name");
     } else {
         panic!("Wrong error {:?}", e);
     }
 }
-
-#[test]
-#[cfg(feature = "json")]
-fn test_error_root_not_table() {
-    match Config::builder()
-        .add_source(File::from_str(r#"false"#, FileFormat::Json))
-        .build()
-    {
-        Ok(_) => panic!("Should not merge if root is not a table"),
-        Err(e) => match e {
-            ConfigError::FileParse { cause, .. } => assert_eq!(
-                "invalid type: boolean `false`, expected a map",
-                format!("{cause}")
-            ),
-            _ => panic!("Wrong error: {:?}", e),
-        },
-    }
-}