Full support for secret injection into configuration files

2025-09-10 20:53:10 -06:00
parent 8ae9b19567
commit 17eba4413d
13 changed files with 647 additions and 377 deletions
@@ -1,166 +1,210 @@
 #[cfg(test)]
 mod tests {
-	use gman::config::{Config, RunConfig};
-	use gman::providers::local::LocalProvider;
-	use gman::providers::SupportedProvider;
+    use gman::config::{Config, RunConfig};
+    use gman::providers::SupportedProvider;
+    use gman::providers::local::LocalProvider;

-	use validator::Validate;
+    use validator::Validate;

-	#[test]
-	fn test_run_config_valid() {
-		let run_config = RunConfig {
-			name: Some("test".to_string()),
-			secrets: Some(vec!["secret1".to_string()]),
-			flag: None,
-			flag_position: None,
-			arg_format: None,
-		};
-		assert!(run_config.validate().is_ok());
-	}
+    #[test]
+    fn test_run_config_valid() {
+        let run_config = RunConfig {
+            name: Some("test".to_string()),
+            secrets: Some(vec!["secret1".to_string()]),
+            flag: None,
+            flag_position: None,
+            arg_format: None,
+            files: None,
+        };
+        assert!(run_config.validate().is_ok());
+    }

-	#[test]
-	fn test_run_config_missing_name() {
-		let run_config = RunConfig {
-			name: None,
-			secrets: Some(vec!["secret1".to_string()]),
-			flag: None,
-			flag_position: None,
-			arg_format: None,
-		};
-		assert!(run_config.validate().is_err());
-	}
+    #[test]
+    fn test_run_config_missing_name() {
+        let run_config = RunConfig {
+            name: None,
+            secrets: Some(vec!["secret1".to_string()]),
+            flag: None,
+            flag_position: None,
+            arg_format: None,
+            files: None,
+        };
+        assert!(run_config.validate().is_err());
+    }

-	#[test]
-	fn test_run_config_missing_secrets() {
-		let run_config = RunConfig {
-			name: Some("test".to_string()),
-			secrets: None,
-			flag: None,
-			flag_position: None,
-			arg_format: None,
-		};
-		assert!(run_config.validate().is_err());
-	}
+    #[test]
+    fn test_run_config_missing_secrets() {
+        let run_config = RunConfig {
+            name: Some("test".to_string()),
+            secrets: None,
+            flag: None,
+            flag_position: None,
+            arg_format: None,
+            files: None,
+        };
+        assert!(run_config.validate().is_err());
+    }

-	#[test]
-	fn test_run_config_invalid_flag_position() {
-		let run_config = RunConfig {
-			name: Some("test".to_string()),
-			secrets: Some(vec!["secret1".to_string()]),
-			flag: Some("--test-flag".to_string()),
-			flag_position: Some(0),
-			arg_format: Some("{key}={value}".to_string()),
-		};
-		assert!(run_config.validate().is_err());
-	}
+    #[test]
+    fn test_run_config_invalid_flag_position() {
+        let run_config = RunConfig {
+            name: Some("test".to_string()),
+            secrets: Some(vec!["secret1".to_string()]),
+            flag: Some("--test-flag".to_string()),
+            flag_position: Some(0),
+            arg_format: Some("{{key}}={{value}}".to_string()),
+            files: None,
+        };
+        assert!(run_config.validate().is_err());
+    }

-	#[test]
-	fn test_run_config_flags_or_none_all_some() {
-		let run_config = RunConfig {
-			name: Some("test".to_string()),
-			secrets: Some(vec!["secret1".to_string()]),
-			flag: Some("--test-flag".to_string()),
-			flag_position: Some(1),
-			arg_format: Some("{key}={value}".to_string()),
-		};
-		assert!(run_config.validate().is_ok());
-	}
+    #[test]
+    fn test_run_config_flags_or_none_all_some() {
+        let run_config = RunConfig {
+            name: Some("test".to_string()),
+            secrets: Some(vec!["secret1".to_string()]),
+            flag: Some("--test-flag".to_string()),
+            flag_position: Some(1),
+            arg_format: Some("{{key}}={{value}}".to_string()),
+            files: None,
+        };
+        assert!(run_config.validate().is_ok());
+    }

-	#[test]
-	fn test_run_config_flags_or_none_all_none() {
-		let run_config = RunConfig {
-			name: Some("test".to_string()),
-			secrets: Some(vec!["secret1".to_string()]),
-			flag: None,
-			flag_position: None,
-			arg_format: None,
-		};
-		assert!(run_config.validate().is_ok());
-	}
+    #[test]
+    fn test_run_config_flags_or_none_all_none() {
+        let run_config = RunConfig {
+            name: Some("test".to_string()),
+            secrets: Some(vec!["secret1".to_string()]),
+            flag: None,
+            flag_position: None,
+            arg_format: None,
+            files: None,
+        };
+        assert!(run_config.validate().is_ok());
+    }

-	#[test]
-	fn test_run_config_flags_or_none_partial_some() {
-		let run_config = RunConfig {
-			name: Some("test".to_string()),
-			secrets: Some(vec!["secret1".to_string()]),
-			flag: Some("--test-flag".to_string()),
-			flag_position: None,
-			arg_format: None,
-		};
-		assert!(run_config.validate().is_err());
-	}
+    #[test]
+    fn test_run_config_flags_or_none_partial_some() {
+        let run_config = RunConfig {
+            name: Some("test".to_string()),
+            secrets: Some(vec!["secret1".to_string()]),
+            flag: Some("--test-flag".to_string()),
+            flag_position: None,
+            arg_format: None,
+            files: None,
+        };
+        assert!(run_config.validate().is_err());
+    }

-	#[test]
-	fn test_run_config_flags_or_none_missing_placeholder() {
-		let run_config = RunConfig {
-			name: Some("test".to_string()),
-			secrets: Some(vec!["secret1".to_string()]),
-			flag: Some("--test-flag".to_string()),
-			flag_position: Some(1),
-			arg_format: Some("key=value".to_string()),
-		};
-		assert!(run_config.validate().is_err());
-	}
+    #[test]
+    fn test_run_config_flags_or_none_missing_placeholder() {
+        let run_config = RunConfig {
+            name: Some("test".to_string()),
+            secrets: Some(vec!["secret1".to_string()]),
+            flag: Some("--test-flag".to_string()),
+            flag_position: Some(1),
+            arg_format: Some("key=value".to_string()),
+            files: None,
+        };
+        assert!(run_config.validate().is_err());
+    }

-	#[test]
-	fn test_config_valid() {
-		let config = Config {
-			provider: SupportedProvider::Local(LocalProvider),
-			password_file: None,
-			git_branch: None,
-			git_remote_url: None,
-			git_user_name: None,
-			git_user_email: Some("test@example.com".to_string()),
-			git_executable: None,
-			run_configs: None,
-		};
-		assert!(config.validate().is_ok());
-	}
+    #[test]
+    fn test_run_config_flags_or_files_all_none() {
+        let run_config = RunConfig {
+            name: Some("test".to_string()),
+            secrets: Some(vec!["secret1".to_string()]),
+            flag: None,
+            flag_position: None,
+            arg_format: None,
+            files: None,
+        };
+        assert!(run_config.validate().is_ok());
+    }

-	#[test]
-	fn test_config_invalid_email() {
-		let config = Config {
-			provider: SupportedProvider::Local(LocalProvider),
-			password_file: None,
-			git_branch: None,
-			git_remote_url: None,
-			git_user_name: None,
-			git_user_email: Some("test".to_string()),
-			git_executable: None,
-			run_configs: None,
-		};
-		assert!(config.validate().is_err());
-	}
+    #[test]
+    fn test_run_config_flags_or_files_files_is_some() {
+        let run_config = RunConfig {
+            name: Some("test".to_string()),
+            secrets: Some(vec!["secret1".to_string()]),
+            flag: None,
+            flag_position: None,
+            arg_format: None,
+            files: Some(Vec::new()),
+        };
+        assert!(run_config.validate().is_ok());
+    }

-	#[test]
-	fn test_config_default() {
-		let config = Config::default();
-		assert_eq!(
-			config.provider,
-			SupportedProvider::Local(LocalProvider)
-		);
-		assert_eq!(config.git_branch, Some("main".to_string()));
-	}
+    #[test]
+    fn test_run_config_flags_or_files_all_some() {
+        let run_config = RunConfig {
+            name: Some("test".to_string()),
+            secrets: Some(vec!["secret1".to_string()]),
+            flag: Some("--test-flag".to_string()),
+            flag_position: Some(1),
+            arg_format: Some("{{key}}={{value}}".to_string()),
+            files: Some(Vec::new()),
+        };
+        assert!(run_config.validate().is_err());
+    }

-	#[test]
-	fn test_config_extract_provider() {
-		let config = Config::default();
-		let provider = config.extract_provider();
-		assert_eq!(provider.name(), "LocalProvider");
-	}
+    #[test]
+    fn test_config_valid() {
+        let config = Config {
+            provider: SupportedProvider::Local(LocalProvider),
+            password_file: None,
+            git_branch: None,
+            git_remote_url: None,
+            git_user_name: None,
+            git_user_email: Some("test@example.com".to_string()),
+            git_executable: None,
+            run_configs: None,
+        };
+        assert!(config.validate().is_ok());
+    }

-	#[test]
-	fn test_config_local_provider_password_file() {
-		let path = Config::local_provider_password_file();
-		let expected_path = dirs::home_dir().map(|p| p.join(".gman_password"));
-		if let Some(p) = &expected_path {
-			if !p.exists() {
-				assert_eq!(path, None);
-			} else {
-				assert_eq!(path, expected_path);
-			}
-		} else {
-			assert_eq!(path, None);
-		}
-	}
-}
+    #[test]
+    fn test_config_invalid_email() {
+        let config = Config {
+            provider: SupportedProvider::Local(LocalProvider),
+            password_file: None,
+            git_branch: None,
+            git_remote_url: None,
+            git_user_name: None,
+            git_user_email: Some("test".to_string()),
+            git_executable: None,
+            run_configs: None,
+        };
+        assert!(config.validate().is_err());
+    }
+
+    #[test]
+    fn test_config_default() {
+        let config = Config::default();
+        assert_eq!(config.provider, SupportedProvider::Local(LocalProvider));
+        assert_eq!(config.git_branch, Some("main".to_string()));
+    }
+
+    #[test]
+    fn test_config_extract_provider() {
+        let config = Config::default();
+        let provider = config.extract_provider();
+        assert_eq!(provider.name(), "LocalProvider");
+    }
+
+    #[test]
+    fn test_config_local_provider_password_file() {
+        let path = Config::local_provider_password_file();
+        let expected_path = dirs::home_dir().map(|p| p.join(".gman_password"));
+        if let Some(p) = &expected_path {
+            if !p.exists() {
+                assert_eq!(path, None);
+            } else {
+                assert_eq!(path, expected_path);
+            }
+        } else {
+            assert_eq!(path, None);
+        }
+    }
+}
@@ -1,6 +1,5 @@
 use gman::providers::local::LocalProviderConfig;

-
 #[test]
 fn test_local_provider_config_default() {
    let config = LocalProviderConfig::default();
@@ -1,5 +1,5 @@
-use gman::providers::{ParseProviderError, SupportedProvider};
 use gman::providers::local::LocalProvider;
+use gman::providers::{ParseProviderError, SupportedProvider};
 use std::str::FromStr;

 #[test]
@@ -17,10 +17,7 @@ fn test_supported_provider_from_str_valid() {
 #[test]
 fn test_supported_provider_from_str_invalid() {
    let err = SupportedProvider::from_str("invalid").unwrap_err();
-    assert_eq!(
-        err.to_string(),
-        "unsupported provider 'invalid'"
-    );
+    assert_eq!(err.to_string(), "unsupported provider 'invalid'");
 }

 #[test]