add Error test, fix clippy

iam/src/error.rs

@@ -97,6 +97,61 @@ pub enum Error {
     Io(std::io::Error),
 }
 
+impl PartialEq for Error {
+    fn eq(&self, other: &Self) -> bool {
+        match (self, other) {
+            (Error::StringError(a), Error::StringError(b)) => a == b,
+            (Error::NoSuchUser(a), Error::NoSuchUser(b)) => a == b,
+            (Error::NoSuchAccount(a), Error::NoSuchAccount(b)) => a == b,
+            (Error::NoSuchServiceAccount(a), Error::NoSuchServiceAccount(b)) => a == b,
+            (Error::NoSuchTempAccount(a), Error::NoSuchTempAccount(b)) => a == b,
+            (Error::NoSuchGroup(a), Error::NoSuchGroup(b)) => a == b,
+            (Error::InvalidServiceType(a), Error::InvalidServiceType(b)) => a == b,
+            (Error::Io(a), Error::Io(b)) => a.kind() == b.kind() && a.to_string() == b.to_string(),
+            // For complex types like PolicyError, CryptoError, JWTError, compare string representations
+            (a, b) => std::mem::discriminant(a) == std::mem::discriminant(b) && a.to_string() == b.to_string(),
+        }
+    }
+}
+
+impl Clone for Error {
+    fn clone(&self) -> Self {
+        match self {
+            Error::PolicyError(e) => Error::StringError(e.to_string()), // Convert to string since PolicyError may not be cloneable
+            Error::StringError(s) => Error::StringError(s.clone()),
+            Error::CryptoError(e) => Error::StringError(format!("crypto: {}", e)), // Convert to string
+            Error::NoSuchUser(s) => Error::NoSuchUser(s.clone()),
+            Error::NoSuchAccount(s) => Error::NoSuchAccount(s.clone()),
+            Error::NoSuchServiceAccount(s) => Error::NoSuchServiceAccount(s.clone()),
+            Error::NoSuchTempAccount(s) => Error::NoSuchTempAccount(s.clone()),
+            Error::NoSuchGroup(s) => Error::NoSuchGroup(s.clone()),
+            Error::NoSuchPolicy => Error::NoSuchPolicy,
+            Error::PolicyInUse => Error::PolicyInUse,
+            Error::GroupNotEmpty => Error::GroupNotEmpty,
+            Error::InvalidArgument => Error::InvalidArgument,
+            Error::IamSysNotInitialized => Error::IamSysNotInitialized,
+            Error::InvalidServiceType(s) => Error::InvalidServiceType(s.clone()),
+            Error::ErrCredMalformed => Error::ErrCredMalformed,
+            Error::CredNotInitialized => Error::CredNotInitialized,
+            Error::InvalidAccessKeyLength => Error::InvalidAccessKeyLength,
+            Error::InvalidSecretKeyLength => Error::InvalidSecretKeyLength,
+            Error::ContainsReservedChars => Error::ContainsReservedChars,
+            Error::GroupNameContainsReservedChars => Error::GroupNameContainsReservedChars,
+            Error::JWTError(e) => Error::StringError(format!("jwt err {}", e)), // Convert to string
+            Error::NoAccessKey => Error::NoAccessKey,
+            Error::InvalidToken => Error::InvalidToken,
+            Error::InvalidAccessKey => Error::InvalidAccessKey,
+            Error::IAMActionNotAllowed => Error::IAMActionNotAllowed,
+            Error::InvalidExpiration => Error::InvalidExpiration,
+            Error::NoSecretKeyWithAccessKey => Error::NoSecretKeyWithAccessKey,
+            Error::NoAccessKeyWithSecretKey => Error::NoAccessKeyWithSecretKey,
+            Error::PolicyTooLarge => Error::PolicyTooLarge,
+            Error::ConfigNotFound => Error::ConfigNotFound,
+            Error::Io(e) => Error::Io(std::io::Error::new(e.kind(), e.to_string())),
+        }
+    }
+}
+
 impl Error {
     pub fn other<E>(error: E) -> Self
     where
@@ -225,3 +280,142 @@ pub fn is_err_no_such_service_account(err: &Error) -> bool {
 //         Error::msg(e.to_string())
 //     }
 // }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::io::{Error as IoError, ErrorKind};
+
+    #[test]
+    fn test_iam_error_to_io_error_conversion() {
+        let iam_errors = vec![
+            Error::NoSuchUser("testuser".to_string()),
+            Error::NoSuchAccount("testaccount".to_string()),
+            Error::InvalidArgument,
+            Error::IAMActionNotAllowed,
+            Error::PolicyTooLarge,
+            Error::ConfigNotFound,
+        ];
+
+        for iam_error in iam_errors {
+            let io_error: std::io::Error = iam_error.clone().into();
+
+            // Check that conversion creates an io::Error
+            assert_eq!(io_error.kind(), ErrorKind::Other);
+
+            // Check that the error message is preserved
+            assert!(io_error.to_string().contains(&iam_error.to_string()));
+        }
+    }
+
+    #[test]
+    fn test_iam_error_from_storage_error() {
+        // Test conversion from StorageError
+        let storage_error = ecstore::error::StorageError::ConfigNotFound;
+        let iam_error: Error = storage_error.into();
+        assert_eq!(iam_error, Error::ConfigNotFound);
+
+        // Test reverse conversion
+        let back_to_storage: ecstore::error::StorageError = iam_error.into();
+        assert_eq!(back_to_storage, ecstore::error::StorageError::ConfigNotFound);
+    }
+
+    #[test]
+    fn test_iam_error_from_policy_error() {
+        use policy::error::Error as PolicyError;
+
+        let policy_errors = vec![
+            (PolicyError::NoSuchUser("user1".to_string()), Error::NoSuchUser("user1".to_string())),
+            (PolicyError::NoSuchPolicy, Error::NoSuchPolicy),
+            (PolicyError::InvalidArgument, Error::InvalidArgument),
+            (PolicyError::PolicyTooLarge, Error::PolicyTooLarge),
+        ];
+
+        for (policy_error, expected_iam_error) in policy_errors {
+            let converted_iam_error: Error = policy_error.into();
+            assert_eq!(converted_iam_error, expected_iam_error);
+        }
+    }
+
+    #[test]
+    fn test_iam_error_other_function() {
+        let custom_error = "Custom IAM error";
+        let iam_error = Error::other(custom_error);
+
+        match iam_error {
+            Error::Io(io_error) => {
+                assert!(io_error.to_string().contains(custom_error));
+                assert_eq!(io_error.kind(), ErrorKind::Other);
+            }
+            _ => panic!("Expected Io variant"),
+        }
+    }
+
+    #[test]
+    fn test_iam_error_from_serde_json() {
+        // Test conversion from serde_json::Error
+        let invalid_json = r#"{"invalid": json}"#;
+        let json_error = serde_json::from_str::<serde_json::Value>(invalid_json).unwrap_err();
+        let iam_error: Error = json_error.into();
+
+        match iam_error {
+            Error::Io(io_error) => {
+                assert_eq!(io_error.kind(), ErrorKind::Other);
+            }
+            _ => panic!("Expected Io variant"),
+        }
+    }
+
+    #[test]
+    fn test_helper_functions() {
+        // Test helper functions for error type checking
+        assert!(is_err_config_not_found(&Error::ConfigNotFound));
+        assert!(!is_err_config_not_found(&Error::NoSuchPolicy));
+
+        assert!(is_err_no_such_policy(&Error::NoSuchPolicy));
+        assert!(!is_err_no_such_policy(&Error::ConfigNotFound));
+
+        assert!(is_err_no_such_user(&Error::NoSuchUser("test".to_string())));
+        assert!(!is_err_no_such_user(&Error::NoSuchAccount("test".to_string())));
+
+        assert!(is_err_no_such_account(&Error::NoSuchAccount("test".to_string())));
+        assert!(!is_err_no_such_account(&Error::NoSuchUser("test".to_string())));
+
+        assert!(is_err_no_such_temp_account(&Error::NoSuchTempAccount("test".to_string())));
+        assert!(!is_err_no_such_temp_account(&Error::NoSuchAccount("test".to_string())));
+
+        assert!(is_err_no_such_group(&Error::NoSuchGroup("test".to_string())));
+        assert!(!is_err_no_such_group(&Error::NoSuchUser("test".to_string())));
+
+        assert!(is_err_no_such_service_account(&Error::NoSuchServiceAccount("test".to_string())));
+        assert!(!is_err_no_such_service_account(&Error::NoSuchAccount("test".to_string())));
+    }
+
+    #[test]
+    fn test_iam_error_io_preservation() {
+        // Test that Io variant preserves original io::Error
+        let original_io = IoError::new(ErrorKind::PermissionDenied, "access denied");
+        let iam_error = Error::Io(original_io);
+
+        let converted_io: std::io::Error = iam_error.into();
+        // Note: Our clone implementation creates a new io::Error with the same kind and message
+        // but it becomes ErrorKind::Other when cloned
+        assert_eq!(converted_io.kind(), ErrorKind::Other);
+        assert!(converted_io.to_string().contains("access denied"));
+    }
+
+    #[test]
+    fn test_error_display_format() {
+        let test_cases = vec![
+            (Error::NoSuchUser("testuser".to_string()), "user 'testuser' does not exist"),
+            (Error::NoSuchAccount("testaccount".to_string()), "account 'testaccount' does not exist"),
+            (Error::InvalidArgument, "invalid arguments specified"),
+            (Error::IAMActionNotAllowed, "action not allowed"),
+            (Error::ConfigNotFound, "config not found"),
+        ];
+
+        for (error, expected_message) in test_cases {
+            assert_eq!(error.to_string(), expected_message);
+        }
+    }
+}