Added unit tests

tests/config_tests.rs

@@ -0,0 +1,166 @@
+#[cfg(test)]
+mod tests {
+	use gman::config::{Config, RunConfig};
+	use gman::providers::local::LocalProvider;
+	use gman::providers::SupportedProvider;
+
+	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_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_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_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_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_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_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_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_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_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);
+		}
+	}
+}

tests/providers/local_tests.rs

@@ -0,0 +1,12 @@
+use gman::providers::local::LocalProviderConfig;
+
+
+#[test]
+fn test_local_provider_config_default() {
+    let config = LocalProviderConfig::default();
+    let expected_path = dirs::home_dir()
+        .map(|p| p.join(".gman_vault"))
+        .and_then(|p| p.to_str().map(|s| s.to_string()))
+        .unwrap_or_else(|| ".gman_vault".into());
+    assert_eq!(config.vault_path, expected_path);
+}

tests/providers/mod_tests.rs

@@ -0,0 +1,36 @@
+use gman::providers::{ParseProviderError, SupportedProvider};
+use gman::providers::local::LocalProvider;
+use std::str::FromStr;
+
+#[test]
+fn test_supported_provider_from_str_valid() {
+    assert_eq!(
+        SupportedProvider::from_str("local").unwrap(),
+        SupportedProvider::Local(LocalProvider)
+    );
+    assert_eq!(
+        SupportedProvider::from_str("LOCAL").unwrap(),
+        SupportedProvider::Local(LocalProvider)
+    );
+}
+
+#[test]
+fn test_supported_provider_from_str_invalid() {
+    let err = SupportedProvider::from_str("invalid").unwrap_err();
+    assert_eq!(
+        err.to_string(),
+        "unsupported provider 'invalid'"
+    );
+}
+
+#[test]
+fn test_supported_provider_display() {
+    let provider = SupportedProvider::Local(LocalProvider);
+    assert_eq!(provider.to_string(), "local");
+}
+
+#[test]
+fn test_parse_provider_error_display() {
+    let err = ParseProviderError::Unsupported("test".to_string());
+    assert_eq!(err.to_string(), "unsupported provider 'test'");
+}