fix test cases for jsonc

Author: up9cloud

Cargo.lock

@@ -6,7 +6,7 @@ use crate::value::{Value, ValueKind};
 
 use jsonc_parser::JsonValue;
 
-pub fn parse(
+pub(crate) fn parse(
     uri: Option<&String>,
     text: &str,
 ) -> Result<Map<String, Value>, Box<dyn Error + Send + Sync>> {
@@ -28,7 +28,7 @@ pub fn parse(
     .map_err(|err| Box::new(err) as Box<dyn Error + Send + Sync>)
 }
 
-fn from_jsonc_value(uri: Option<&String>, value: JsonValue) -> Value {
+fn from_jsonc_value(uri: Option<&String>, value: JsonValue<'_>) -> Value {
     let vk = match value {
         JsonValue::Null => ValueKind::Nil,
         JsonValue::String(v) => ValueKind::String(v.to_string()),

src/file/format/jsonc.rs

@@ -4,39 +4,46 @@ use serde_derive::Deserialize;
 
 use config::{Config, File, FileFormat, Map, Value};
 use float_cmp::ApproxEqUlps;
-use std::path::PathBuf;
-
-#[derive(Debug, Deserialize)]
-struct Place {
-    name: String,
-    longitude: f64,
-    latitude: f64,
-    favorite: bool,
-    telephone: Option<String>,
-    reviews: u64,
-    creator: Map<String, Value>,
-    rating: Option<f32>,
-}
-
-#[derive(Debug, Deserialize)]
-struct Settings {
-    debug: f64,
-    production: Option<String>,
-    place: Place,
-    #[serde(rename = "arr")]
-    elements: Vec<String>,
-}
-
-fn make() -> Config {
-    Config::builder()
-        .add_source(File::new("tests/Settings", FileFormat::Jsonc))
-        .build()
-        .unwrap()
+use snapbox::{assert_data_eq, str};
+
+fn get_config_file_path(suffix: &str) -> String {
+    let path = std::path::Path::new(file!());
+    format!(
+        "{}/{}/{}{}.jsonc",
+        env!("CARGO_MANIFEST_DIR"),
+        path.parent().unwrap().to_str().unwrap(),
+        path.file_stem().unwrap().to_str().unwrap(),
+        suffix
+    )
 }
 
 #[test]
 fn test_file() {
-    let c = make();
+    #[derive(Debug, Deserialize)]
+    struct Place {
+        name: String,
+        longitude: f64,
+        latitude: f64,
+        favorite: bool,
+        telephone: Option<String>,
+        reviews: u64,
+        creator: Map<String, Value>,
+        rating: Option<f32>,
+    }
+    
+    #[derive(Debug, Deserialize)]
+    struct Settings {
+        debug: f64,
+        production: Option<String>,
+        place: Place,
+        #[serde(rename = "arr")]
+        elements: Vec<String>,
+    }
+
+    let c = Config::builder()
+        .add_source(File::new(&get_config_file_path(""), FileFormat::Jsonc))
+        .build()
+        .unwrap();
 
     // Deserialize the entire file as single struct
     let s: Settings = c.try_deserialize().unwrap();
@@ -52,12 +59,12 @@ fn test_file() {
     assert_eq!(s.place.telephone, None);
     assert_eq!(s.elements.len(), 10);
     assert_eq!(s.elements[3], "4".to_string());
-    if cfg!(feature = "TODO: preserve_order") {
+    if cfg!(feature = "preserve_order") {
         assert_eq!(
             s.place
                 .creator
                 .into_iter()
-                .collect::<Vec<(String, config::Value)>>(),
+                .collect::<Vec<(String, Value)>>(),
             vec![
                 ("name".to_string(), "John Smith".into()),
                 ("username".into(), "jsmith".into()),
@@ -74,69 +81,52 @@ fn test_file() {
 
 #[test]
 fn test_error_parse() {
+    let f = get_config_file_path(".error");
     let res = Config::builder()
-        .add_source(File::new("tests/Settings-invalid", FileFormat::Jsonc))
+        .add_source(File::new(&f, FileFormat::Jsonc))
         .build();
 
-    let path_with_extension: PathBuf = ["tests", "Settings-invalid.jsonc"].iter().collect();
-
     assert!(res.is_err());
     assert_eq!(
         res.unwrap_err().to_string(),
         format!(
             "Expected a colon after the string or word in an object property on line 4 column 1. in {}",
-            path_with_extension.display()
+            std::path::Path::new(&f)
+                .strip_prefix(std::env::current_dir().unwrap())
+                .unwrap_or(std::path::Path::new(&f))
+                .display()
         )
     );
 }
 
-#[derive(Debug, Deserialize, PartialEq)]
-enum EnumSettings {
-    Bar(String),
-}
-
-#[derive(Debug, Deserialize, PartialEq)]
-struct StructSettings {
-    foo: String,
-    bar: String,
-}
 #[derive(Debug, Deserialize, PartialEq)]
 #[allow(non_snake_case)]
-struct CapSettings {
+struct OverrideSettings {
+    foo: String,
     FOO: String,
+    bar: String,
 }
 
 #[test]
 fn test_override_uppercase_value_for_struct() {
     std::env::set_var("APP_FOO", "I HAVE BEEN OVERRIDDEN_WITH_UPPER_CASE");
 
     let cfg = Config::builder()
-        .add_source(File::new("tests/Settings", FileFormat::Jsonc))
+        .add_source(File::new(&get_config_file_path(""), FileFormat::Jsonc))
         .add_source(config::Environment::with_prefix("APP").separator("_"))
         .build()
         .unwrap();
 
-    let cap_settings = cfg.clone().try_deserialize::<CapSettings>();
-    let lower_settings = cfg.try_deserialize::<StructSettings>().unwrap();
+    let settings = cfg.try_deserialize::<OverrideSettings>();
 
-    match cap_settings {
+    match settings {
         Ok(v) => {
             // this assertion will ensure that the map has only lowercase keys
-            assert_ne!(v.FOO, "FOO should be overridden");
-            assert_eq!(
-                lower_settings.foo,
-                "I HAVE BEEN OVERRIDDEN_WITH_UPPER_CASE".to_string()
-            );
+            assert_eq!(v.FOO, "FOO should be overridden");
+            assert_eq!(v.foo, "I HAVE BEEN OVERRIDDEN_WITH_UPPER_CASE".to_string());
         }
         Err(e) => {
-            if e.to_string().contains("missing field `FOO`") {
-                assert_eq!(
-                    lower_settings.foo,
-                    "I HAVE BEEN OVERRIDDEN_WITH_UPPER_CASE".to_string()
-                );
-            } else {
-                panic!("{}", e);
-            }
+            panic!("{}", e);
         }
     }
 }
@@ -146,33 +136,36 @@ fn test_override_lowercase_value_for_struct() {
     std::env::set_var("config_foo", "I have been overridden_with_lower_case");
 
     let cfg = Config::builder()
-        .add_source(File::new("tests/Settings", FileFormat::Jsonc))
+        .add_source(File::new(&get_config_file_path(""), FileFormat::Jsonc))
         .add_source(config::Environment::with_prefix("config").separator("_"))
         .build()
         .unwrap();
 
-    let values: StructSettings = cfg.try_deserialize().unwrap();
-    assert_eq!(
-        values.foo,
-        "I have been overridden_with_lower_case".to_string()
+    let values: OverrideSettings = cfg.try_deserialize().unwrap();
+    assert_eq!(values.foo, "I have been overridden_with_lower_case".to_string()
     );
-    assert_ne!(values.foo, "I am bar".to_string());
+}
+
+#[derive(Debug, Deserialize, PartialEq)]
+enum EnumSettings {
+    Bar(String),
 }
 
 #[test]
 fn test_override_uppercase_value_for_enums() {
     std::env::set_var("APPS_BAR", "I HAVE BEEN OVERRIDDEN_WITH_UPPER_CASE");
 
     let cfg = Config::builder()
-        .add_source(File::new("tests/Settings-enum-test", FileFormat::Jsonc))
+        .add_source(File::new(&get_config_file_path(".enum"), FileFormat::Jsonc))
         .add_source(config::Environment::with_prefix("APPS").separator("_"))
         .build()
         .unwrap();
-    let val: EnumSettings = cfg.try_deserialize().unwrap();
 
-    assert_eq!(
-        val,
-        EnumSettings::Bar("I HAVE BEEN OVERRIDDEN_WITH_UPPER_CASE".to_string())
+    let param = cfg.try_deserialize::<EnumSettings>();
+    assert!(param.is_err());
+    assert_data_eq!(
+        param.unwrap_err().to_string(),
+        str!["enum EnumSettings does not have variant constructor bar"]
     );
 }
 
@@ -181,15 +174,15 @@ fn test_override_lowercase_value_for_enums() {
     std::env::set_var("test_bar", "I have been overridden_with_lower_case");
 
     let cfg = Config::builder()
-        .add_source(File::new("tests/Settings-enum-test", FileFormat::Jsonc))
+        .add_source(File::new(&get_config_file_path(".enum"), FileFormat::Jsonc))
         .add_source(config::Environment::with_prefix("test").separator("_"))
         .build()
         .unwrap();
 
-    let param: EnumSettings = cfg.try_deserialize().unwrap();
-
-    assert_eq!(
-        param,
-        EnumSettings::Bar("I have been overridden_with_lower_case".to_string())
+    let param = cfg.try_deserialize::<EnumSettings>();
+    assert!(param.is_err());
+    assert_data_eq!(
+        param.unwrap_err().to_string(),
+        str!["enum EnumSettings does not have variant constructor bar"]
     );
 }

tests/Settings-enum-test.jsonc renamed to tests/testsuite/file_jsonc.enum.jsonc

@@ -11,6 +11,7 @@ pub mod file;
 pub mod file_ini;
 pub mod file_json;
 pub mod file_json5;
+pub mod file_jsonc;
 pub mod file_ron;
 pub mod file_toml;
 pub mod file_yaml;