Added unit and integration tests

tests/bin/gman/main_tests.rs

@@ -0,0 +1,22 @@
+use gman::providers::SupportedProvider;
+use gman::providers::local::LocalProvider;
+use pretty_assertions::assert_eq;
+
+#[test]
+fn test_provider_kind_from() {
+    enum ProviderKind {
+        Local,
+    }
+
+    impl From<ProviderKind> for SupportedProvider {
+        fn from(k: ProviderKind) -> Self {
+            match k {
+                ProviderKind::Local => SupportedProvider::Local(LocalProvider),
+            }
+        }
+    }
+
+    let provider_kind = ProviderKind::Local;
+    let supported_provider: SupportedProvider = provider_kind.into();
+    assert_eq!(supported_provider, SupportedProvider::Local(LocalProvider));
+}

tests/bin/gman/mod.rs

@@ -0,0 +1 @@
+mod main_tests;

tests/bin/mod.rs

@@ -0,0 +1 @@
+mod gman;

tests/config_tests.rs

@@ -3,6 +3,7 @@ mod tests {
     use gman::config::{Config, RunConfig};
     use gman::providers::SupportedProvider;
     use gman::providers::local::LocalProvider;
+    use pretty_assertions::{assert_eq, assert_str_eq};
 
     use validator::Validate;
 
@@ -190,7 +191,7 @@ mod tests {
     fn test_config_extract_provider() {
         let config = Config::default();
         let provider = config.extract_provider();
-        assert_eq!(provider.name(), "LocalProvider");
+        assert_str_eq!(provider.name(), "LocalProvider");
     }
 
     #[test]

tests/providers/git_sync_tests.rs

@@ -0,0 +1,53 @@
+use anyhow::Result;
+use validator::Validate;
+
+// Redefining the struct here for testing purposes
+pub struct SyncOpts<'a> {
+    pub remote_url: &'a Option<String>,
+    pub branch: &'a Option<String>,
+}
+
+impl<'a> Validate for SyncOpts<'a> {
+    fn validate(&self) -> Result<(), validator::ValidationErrors> {
+        if self.remote_url.is_none() {
+            return Err(validator::ValidationErrors::new());
+        }
+        if self.branch.is_none() {
+            return Err(validator::ValidationErrors::new());
+        }
+        Ok(())
+    }
+}
+
+#[test]
+fn test_sync_opts_validation_valid() {
+    let remote_url = Some("https://github.com/user/repo.git".to_string());
+    let branch = Some("main".to_string());
+    let opts = SyncOpts {
+        remote_url: &remote_url,
+        branch: &branch,
+    };
+    assert!(opts.validate().is_ok());
+}
+
+#[test]
+fn test_sync_opts_validation_missing_remote_url() {
+    let remote_url = None;
+    let branch = Some("main".to_string());
+    let opts = SyncOpts {
+        remote_url: &remote_url,
+        branch: &branch,
+    };
+    assert!(opts.validate().is_err());
+}
+
+#[test]
+fn test_sync_opts_validation_missing_branch() {
+    let remote_url = Some("https://github.com/user/repo.git".to_string());
+    let branch = None;
+    let opts = SyncOpts {
+        remote_url: &remote_url,
+        branch: &branch,
+    };
+    assert!(opts.validate().is_err());
+}

tests/providers/local_tests.rs

@@ -1,4 +1,5 @@
 use gman::providers::local::LocalProviderConfig;
+use pretty_assertions::assert_str_eq;
 
 #[test]
 fn test_local_provider_config_default() {
@@ -7,5 +8,14 @@ fn test_local_provider_config_default() {
         .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);
+    assert_str_eq!(config.vault_path, expected_path);
+}
+
+#[test]
+fn test_local_provider_name() {
+    use gman::providers::SecretProvider;
+    use gman::providers::local::LocalProvider;
+
+    let provider = LocalProvider;
+    assert_str_eq!(provider.name(), "LocalProvider");
 }

tests/providers/mod.rs

@@ -0,0 +1,3 @@
+mod git_sync_tests;
+mod local_tests;
+mod provider_tests;

tests/providers/provider_tests.rs

@@ -1,7 +1,29 @@
 use gman::providers::local::LocalProvider;
 use gman::providers::{ParseProviderError, SupportedProvider};
+use pretty_assertions::{assert_eq, assert_str_eq};
 use std::str::FromStr;
 
+#[test]
+fn test_supported_provider_from_str() {
+    assert_eq!(
+        SupportedProvider::from_str("local").unwrap(),
+        SupportedProvider::Local(LocalProvider)
+    );
+    assert_eq!(
+        SupportedProvider::from_str(" Local ").unwrap(),
+        SupportedProvider::Local(LocalProvider)
+    );
+    assert!(matches!(
+        SupportedProvider::from_str("invalid"),
+        Err(ParseProviderError::Unsupported(_))
+    ));
+}
+
+#[test]
+fn test_supported_provider_display() {
+    assert_str_eq!(SupportedProvider::Local(LocalProvider).to_string(), "local");
+}
+
 #[test]
 fn test_supported_provider_from_str_valid() {
     assert_eq!(
@@ -17,13 +39,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'");
-}
-
-#[test]
-fn test_supported_provider_display() {
-    let provider = SupportedProvider::Local(LocalProvider);
-    assert_eq!(provider.to_string(), "local");
+    assert_str_eq!(err.to_string(), "unsupported provider 'invalid'");
 }
 
 #[test]

tests/tests.rs

@@ -0,0 +1,3 @@
+mod bin;
+mod config_tests;
+mod providers;