better functora-cfg tests wip

Author: functora

rust/functora-cfg/tests/integration.rs

@@ -1,84 +1,132 @@
-use std::collections::HashMap;
-
+use clap::{Args, Parser, Subcommand};
+use functora_cfg::*;
 use serde::{Deserialize, Serialize};
 use serial_test::serial;
+use std::collections::HashMap;
+use std::fmt::Debug;
 use temp_env::with_vars;
 
-fn new_cfg(cli: &Cli) -> Cfg {
-    let def = Cli {
-        cfg: None,
-        host: Some("127.0.0.1".into()),
-        port: Some(8080),
-        debug: Some(false),
-        nest_val: Some(CfgNest {
-            name: "foo".into(),
-            value: 42,
-        }),
-        many_val: HashMap::new(),
-        tags: None,
-    };
-    functora_cfg::Cfg {
-        default: &def,
-        file_path: |cli: &Cli| cli.cfg.as_deref(),
-        env_prefix: "FUNCTORA",
-        command_line: cli,
-    }
-    .eval()
-    .unwrap()
-}
-
-#[derive(Debug, Serialize, Deserialize, PartialEq)]
+#[derive(
+    Eq, PartialEq, Debug, Clone, Serialize, Deserialize,
+)]
 struct Cfg {
     host: String,
     port: u16,
-    debug: bool,
-    nest_val: Option<CfgNest>,
-    many_val: HashMap<usize, CfgNest>,
-    tags: Option<Vec<String>>,
+    logs: bool,
+    main_account: Account,
+    sub_accounts: HashMap<String, Account>,
+}
+
+impl Cfg {
+    pub fn new(
+        cli: &Cli<IdClap<HashMap<String, Account>>>,
+    ) -> Self {
+        functora_cfg::Cfg {
+            default: &Cli::def(),
+            file_path: |cli: &Cli<
+                IdClap<HashMap<String, Account>>,
+            >| cli.toml.as_deref(),
+            env_prefix: "FUNCTORA",
+            command_line: cli,
+        }
+        .eval()
+        .unwrap()
+    }
 }
 
-#[derive(Debug, Serialize, Deserialize, PartialEq)]
-struct CfgNest {
-    name: String,
-    value: i32,
+#[derive(
+    Eq,
+    PartialEq,
+    Ord,
+    PartialOrd,
+    Debug,
+    Clone,
+    Serialize,
+    Deserialize,
+    Args,
+)]
+struct Account {
+    #[arg(long)]
+    alias: String,
+    #[arg(long)]
+    balance: i32,
+    #[arg(long)]
+    tags: Option<Vec<String>>,
 }
 
-#[derive(Debug, Serialize)]
-struct Cli {
-    cfg: Option<String>,
+#[derive(
+    Eq,
+    PartialEq,
+    Debug,
+    Clone,
+    Serialize,
+    Deserialize,
+    Parser,
+)]
+#[command(version, about, long_about = None)]
+struct Cli<T>
+where
+    T: Eq
+        + PartialEq
+        + Debug
+        + Clone
+        + Serialize
+        + Subcommand,
+{
+    #[arg(long)]
+    toml: Option<String>,
+    #[arg(long)]
     host: Option<String>,
+    #[arg(long)]
     port: Option<u16>,
-    debug: Option<bool>,
-    nest_val: Option<CfgNest>,
-    many_val: HashMap<usize, CfgNest>,
-    tags: Option<Vec<String>>,
+    #[arg(long)]
+    logs: Option<bool>,
+    #[command(flatten)]
+    main_account: Option<Account>,
+    #[command(subcommand)]
+    sub_accounts: T,
+}
+
+impl Cli<IdClap<HashMap<String, Account>>> {
+    pub fn def() -> Self {
+        Cli {
+            toml: None,
+            host: Some("127.0.0.1".into()),
+            port: Some(8080),
+            logs: Some(false),
+            main_account: Some(Account {
+                alias: "foo".into(),
+                balance: 42,
+                tags: None,
+            }),
+            sub_accounts: IdClap(HashMap::new()),
+        }
+    }
 }
 
 #[test]
 #[serial]
 fn defaults_only() {
-    let def = Cfg {
-        host: "127.0.0.1".into(),
-        port: 8080,
-        debug: false,
-        nest_val: Some(CfgNest {
-            name: "foo".into(),
-            value: 42,
-        }),
-        many_val: HashMap::new(),
-        tags: None,
-    };
-    let cli = Cli {
-        cfg: None,
+    let lhs = Cfg::new(&Cli {
+        toml: None,
         host: None,
         port: None,
-        debug: None,
-        nest_val: None,
-        many_val: HashMap::new(),
-        tags: None,
+        logs: None,
+        main_account: None,
+        sub_accounts: IdClap(HashMap::new()),
+    });
+    let rhs = Cfg {
+        host: "127.0.0.1".into(),
+        port: 8080,
+        logs: false,
+        main_account: Account {
+            alias: "foo".into(),
+            balance: 42,
+            tags: None,
+        },
+        sub_accounts: HashMap::new(),
     };
-    let cfg: Cfg = new_cfg(&cli);
-    assert_eq!(cfg, def);
+    assert_eq!(lhs, rhs);
 }
 
 #[test]
@@ -88,35 +136,34 @@ fn with_file_override() {
     let file = r#"
         host = "192.168.1.100"
         port = 9090
-        debug = true
+        logs = true
         tags = ["a", "b"]
 
-        [many_val.1]
-        name = "hello"
-        value = 123
+        [sub_accounts.alice]
+        alias = "hello"
+        balance = 123
     "#;
     std::fs::write(&path, file).unwrap();
     let cli = Cli {
-        cfg: Some(path.to_string_lossy().into_owned()),
+        toml: Some(path.to_string_lossy().into_owned()),
         host: None,
         port: None,
-        debug: None,
-        nest_val: None,
-        many_val: HashMap::new(),
-        tags: None,
+        logs: None,
+        main_account: None,
+        sub_accounts: IdClap(HashMap::new()),
     };
-    let cfg: Cfg = new_cfg(&cli);
+    let cfg: Cfg = Cfg::new(&cli);
     assert_eq!(cfg.host, "192.168.1.100");
     assert_eq!(cfg.port, 9090);
-    assert_eq!(cfg.debug, true);
-    assert_eq!(cfg.tags.unwrap(), vec!["a", "b"]);
+    assert_eq!(cfg.logs, true);
     assert_eq!(
-        cfg.many_val,
+        cfg.sub_accounts,
         HashMap::from([(
-            1,
-            CfgNest {
-                name: "hello".into(),
-                value: 123
+            "alice".into(),
+            Account {
+                alias: "hello".into(),
+                balance: 123,
+                tags: None,
             }
         )])
     );
@@ -126,42 +173,49 @@ fn with_file_override() {
 #[serial]
 fn env_override() {
     let cli = Cli {
-        cfg: None,
+        toml: None,
         host: None,
         port: None,
-        debug: None,
-        nest_val: None,
-        many_val: HashMap::new(),
-        tags: None,
+        logs: None,
+        main_account: None,
+        sub_accounts: IdClap(HashMap::new()),
     };
     with_vars(
         vec![
             ("FUNCTORA__HOST", Some("10.0.0.1")),
             ("FUNCTORA__PORT", Some("7070")),
-            ("FUNCTORA__DEBUG", Some("true")),
-            ("FUNCTORA__NEST_VAL__NAME", Some("bar")),
-            ("FUNCTORA__MANY_VAL__0__NAME", Some("buz")),
-            ("FUNCTORA__MANY_VAL__0__VALUE", Some("1")),
+            ("FUNCTORA__LOGS", Some("true")),
+            ("FUNCTORA__MAIN_ACCOUNT__ALIAS", Some("bar")),
+            (
+                "FUNCTORA__SUB_ACCOUNTS__BOB__ALIAS",
+                Some("buz"),
+            ),
+            (
+                "FUNCTORA__SUB_ACCOUNTS__BOB__BALANCE",
+                Some("1"),
+            ),
         ],
         || {
-            let cfg: Cfg = new_cfg(&cli);
+            let cfg: Cfg = Cfg::new(&cli);
             assert_eq!(cfg.host, "10.0.0.1");
             assert_eq!(cfg.port, 7070);
-            assert_eq!(cfg.debug, true);
+            assert_eq!(cfg.logs, true);
             assert_eq!(
-                cfg.nest_val,
-                Some(CfgNest {
-                    name: "bar".into(),
-                    value: 42
-                })
+                cfg.main_account,
+                Account {
+                    alias: "bar".into(),
+                    balance: 42,
+                    tags: None,
+                }
             );
             assert_eq!(
-                cfg.many_val,
+                cfg.sub_accounts,
                 HashMap::from([(
-                    0,
-                    CfgNest {
-                        name: "buz".into(),
-                        value: 1
+                    "bob".into(),
+                    Account {
+                        alias: "buz".into(),
+                        balance: 1,
+                        tags: None,
                     }
                 )])
             );
@@ -173,34 +227,31 @@ fn env_override() {
 #[serial]
 fn cli_override() {
     let cli = Cli {
-        cfg: None,
+        toml: None,
         host: Some("cli.host".into()),
         port: Some(6060),
-        debug: Some(true),
-        nest_val: None,
-        many_val: HashMap::new(),
-        tags: Some(vec!["cli1".into(), "cli2".into()]),
+        logs: Some(true),
+        main_account: None,
+        sub_accounts: IdClap(HashMap::new()),
     };
-    let cfg: Cfg = new_cfg(&cli);
+    let cfg: Cfg = Cfg::new(&cli);
     assert_eq!(cfg.host, "cli.host");
     assert_eq!(cfg.port, 6060);
-    assert_eq!(cfg.debug, true);
-    assert_eq!(cfg.tags.unwrap(), vec!["cli1", "cli2"]);
+    assert_eq!(cfg.logs, true);
 }
 
 #[test]
 #[serial]
 fn nested_struct() {
     let cli = Cli {
-        cfg: None,
+        toml: None,
         host: None,
         port: None,
-        debug: None,
-        nest_val: None,
-        many_val: HashMap::new(),
-        tags: None,
+        logs: None,
+        main_account: None,
+        sub_accounts: IdClap(HashMap::new()),
     };
-    let cfg: Cfg = new_cfg(&cli);
-    assert_eq!(cfg.nest_val.as_ref().unwrap().name, "foo");
-    assert_eq!(cfg.nest_val.as_ref().unwrap().value, 42);
+    let cfg: Cfg = Cfg::new(&cli);
+    assert_eq!(cfg.main_account.alias, "foo");
+    assert_eq!(cfg.main_account.balance, 42);
 }