test(env): Add tests for env variable prefixing behavior

Add tests that demonstrate the desired behavior of env variable
prefixing using hardcoded prefixed env names. These tests pass with
the current code and will be ported to use the new next_env_prefix
/ env_prefix API in the next commit.

Includes both builder and derive tests covering:
- Basic prefix application
- Multiple args with prefix
- Prefix reset
- Arg-level prefix
- Arg override of command prefix
- Flatten with prefix on the flattened struct
- Flatten with prefix on the flatten field

Author: veeceey

tests/builder/env.rs

@@ -423,3 +423,130 @@ fn value_parser_invalid() {
 
     assert!(r.is_err());
 }
+
+#[test]
+fn env_prefix_basic() {
+    env::set_var("MYAPP_CONFIG", "test_value");
+
+    let r = Command::new("myapp")
+        .arg(
+            Arg::new("config")
+                .long("config")
+                .env("MYAPP_CONFIG")
+                .action(ArgAction::Set),
+        )
+        .try_get_matches_from(vec![""]);
+
+    assert!(r.is_ok(), "{}", r.unwrap_err());
+    let m = r.unwrap();
+    assert_eq!(
+        m.get_one::<String>("config").map(|v| v.as_str()).unwrap(),
+        "test_value"
+    );
+}
+
+#[test]
+fn env_prefix_multiple_args() {
+    env::set_var("APP_HOST", "localhost");
+    env::set_var("APP_PORT", "8080");
+
+    let r = Command::new("app")
+        .arg(
+            Arg::new("host")
+                .long("host")
+                .env("APP_HOST")
+                .action(ArgAction::Set),
+        )
+        .arg(
+            Arg::new("port")
+                .long("port")
+                .env("APP_PORT")
+                .action(ArgAction::Set),
+        )
+        .try_get_matches_from(vec![""]);
+
+    assert!(r.is_ok(), "{}", r.unwrap_err());
+    let m = r.unwrap();
+    assert_eq!(
+        m.get_one::<String>("host").map(|v| v.as_str()).unwrap(),
+        "localhost"
+    );
+    assert_eq!(
+        m.get_one::<String>("port").map(|v| v.as_str()).unwrap(),
+        "8080"
+    );
+}
+
+#[test]
+fn env_prefix_reset() {
+    env::set_var("PFX_FIRST", "val1");
+
+    let r = Command::new("app")
+        .arg(
+            Arg::new("first")
+                .long("first")
+                .env("PFX_FIRST")
+                .action(ArgAction::Set),
+        )
+        .arg(
+            Arg::new("second")
+                .long("second")
+                .env("SECOND")
+                .action(ArgAction::Set)
+                .default_value("default"),
+        )
+        .try_get_matches_from(vec![""]);
+
+    assert!(r.is_ok(), "{}", r.unwrap_err());
+    let m = r.unwrap();
+    assert_eq!(
+        m.get_one::<String>("first").map(|v| v.as_str()).unwrap(),
+        "val1"
+    );
+    assert_eq!(
+        m.get_one::<String>("second").map(|v| v.as_str()).unwrap(),
+        "default"
+    );
+}
+
+#[test]
+fn env_prefix_arg_level() {
+    env::set_var("CUSTOM_DB", "mydb");
+
+    let r = Command::new("app")
+        .arg(
+            Arg::new("db")
+                .long("db")
+                .env("CUSTOM_DB")
+                .action(ArgAction::Set),
+        )
+        .try_get_matches_from(vec![""]);
+
+    assert!(r.is_ok(), "{}", r.unwrap_err());
+    let m = r.unwrap();
+    assert_eq!(
+        m.get_one::<String>("db").map(|v| v.as_str()).unwrap(),
+        "mydb"
+    );
+}
+
+#[test]
+fn env_prefix_arg_overrides_command() {
+    env::set_var("OVERRIDE_HOST", "overridden");
+
+    let r = Command::new("app")
+        .arg(
+            Arg::new("host")
+                .long("host")
+                .env("OVERRIDE_HOST")
+                .action(ArgAction::Set),
+        )
+        .try_get_matches_from(vec![""]);
+
+    assert!(r.is_ok(), "{}", r.unwrap_err());
+    let m = r.unwrap();
+    assert_eq!(
+        m.get_one::<String>("host").map(|v| v.as_str()).unwrap(),
+        "overridden"
+    );
+}

tests/derive/env_prefix.rs

@@ -0,0 +1,81 @@
+#![cfg(feature = "env")]
+
+use clap::{Args, Parser};
+use std::env;
+
+#[test]
+fn command_next_env_prefix_applied() {
+    #[derive(Debug, Clone, Parser)]
+    struct CliOptions {
+        #[arg(long, env = "MYAPP_CONFIG")]
+        config: Option<String>,
+
+        #[arg(long)]
+        verbose: bool,
+    }
+
+    let cmd = <CliOptions as clap::CommandFactory>::command();
+
+    let config_arg = cmd
+        .get_arguments()
+        .find(|a| a.get_id() == "config")
+        .unwrap();
+    assert_eq!(
+        config_arg.get_env().unwrap(),
+        std::ffi::OsStr::new("MYAPP_CONFIG")
+    );
+}
+
+#[test]
+fn command_next_env_prefix_value_resolved() {
+    env::set_var("DERIVE_APP_HOST", "localhost");
+
+    #[derive(Debug, Clone, Parser)]
+    struct CliOptions {
+        #[arg(long, env = "DERIVE_APP_HOST")]
+        host: Option<String>,
+    }
+
+    let m = CliOptions::try_parse_from(vec![""]).unwrap();
+    assert_eq!(m.host.as_deref(), Some("localhost"));
+}
+
+#[test]
+fn command_next_env_prefix_with_flatten() {
+    env::set_var("FLAT_APP_DB", "mydb");
+
+    #[derive(Debug, Clone, Args)]
+    struct DbArgs {
+        #[arg(long, env = "FLAT_APP_DB")]
+        db: Option<String>,
+    }
+
+    #[derive(Debug, Clone, Parser)]
+    struct CliOptions {
+        #[command(flatten)]
+        db_args: DbArgs,
+    }
+
+    let m = CliOptions::try_parse_from(vec![""]).unwrap();
+    assert_eq!(m.db_args.db.as_deref(), Some("mydb"));
+}
+
+#[test]
+fn flatten_field_with_env_prefix() {
+    env::set_var("FIELD_PFX_PORT", "9090");
+
+    #[derive(Debug, Clone, Args)]
+    struct ServerArgs {
+        #[arg(long, env = "FIELD_PFX_PORT")]
+        port: Option<String>,
+    }
+
+    #[derive(Debug, Clone, Parser)]
+    struct CliOptions {
+        #[command(flatten)]
+        server: ServerArgs,
+    }
+
+    let m = CliOptions::try_parse_from(vec![""]).unwrap();
+    assert_eq!(m.server.port.as_deref(), Some("9090"));
+}