rustsf 0.0.1

Rust Salesforce API Client
Documentation
use std::fmt;
use crate::responses::error_response::ErrorResponse;
use crate::responses::token_error_response::TokenErrorResponse;
use reqwest::header::InvalidHeaderValue;

#[derive(Debug)]
#[non_exhaustive]
pub enum Error {
    NotLoggedIn,
    ConfigError(String),
    TokenError(TokenErrorResponse),
    HttpError(reqwest::Error),
    HeaderError(InvalidHeaderValue),
    DeserializeError(serde_json::Error),
    ErrorResponses(Vec<ErrorResponse>),
    DescribeError(ErrorResponse),
    LoginError(ErrorResponse),
}

impl std::error::Error for Error {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        match self {
            Error::HttpError(e) => Some(e),
            Error::HeaderError(e) => Some(e),
            Error::DeserializeError(e) => Some(e),
            _ => None,
        }
    }
}

impl fmt::Display for Error {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            Error::NotLoggedIn => write!(f, "Not logged in"),
            Error::ConfigError(msg) => write!(f, "Configuration error: {}", msg),
            Error::TokenError(resp) => write!(f, "Invalid token {:?}", resp),
            Error::HttpError(e) => write!(f, "HTTP request to Salesforce failed: {}", e),
            Error::HeaderError(e) => write!(f, "Invalid header value: {}", e),
            Error::DeserializeError(e) => write!(f, "Could not deserialize response: {}", e),
            Error::ErrorResponses(resp) => write!(f, "Error response from Salesforce {:?}", resp),
            Error::DescribeError(resp) => write!(f, "Error completing describe {:?}", resp),
            Error::LoginError(resp) => write!(f, "Error logging in {:?}", resp),
        }
    }
}

impl From<reqwest::Error> for Error {
    fn from(e: reqwest::Error) -> Self {
        Error::HttpError(e)
    }
}

impl From<InvalidHeaderValue> for Error {
    fn from(e: InvalidHeaderValue) -> Self {
        Error::HeaderError(e)
    }
}

impl From<serde_json::Error> for Error {
    fn from(e: serde_json::Error) -> Self {
        Error::DeserializeError(e)
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use std::error::Error as StdError;

    #[test]
    fn test_display_not_logged_in() {
        let err = Error::NotLoggedIn;
        assert_eq!(format!("{}", err), "Not logged in");
    }

    #[test]
    fn test_display_config_error() {
        let err = Error::ConfigError("client_id is required".to_string());
        assert_eq!(
            format!("{}", err),
            "Configuration error: client_id is required"
        );
    }

    #[test]
    fn test_display_token_error() {
        let token_err: TokenErrorResponse = serde_json::from_str(
            r#"{"error":"invalid_grant","error_description":"bad credentials"}"#,
        )
        .unwrap();
        let err = Error::TokenError(token_err);
        let display = format!("{}", err);
        assert!(display.contains("Invalid token"));
        assert!(display.contains("invalid_grant"));
    }

    #[test]
    fn test_display_deserialize_error() {
        let json_err = serde_json::from_str::<String>("invalid json").unwrap_err();
        let err = Error::DeserializeError(json_err);
        let display = format!("{}", err);
        assert!(display.starts_with("Could not deserialize response: "));
    }

    #[test]
    fn test_display_header_error() {
        let header_err = reqwest::header::HeaderValue::from_str("\0").unwrap_err();
        let err = Error::HeaderError(header_err);
        let display = format!("{}", err);
        assert!(display.starts_with("Invalid header value: "));
    }

    #[test]
    fn test_display_error_responses() {
        let responses = vec![ErrorResponse {
            message: "Record not found".to_string(),
            error_code: "NOT_FOUND".to_string(),
            fields: None,
        }];
        let err = Error::ErrorResponses(responses);
        let display = format!("{}", err);
        assert!(display.contains("Error response from Salesforce"));
        assert!(display.contains("NOT_FOUND"));
    }

    #[test]
    fn test_display_describe_error() {
        let resp = ErrorResponse {
            message: "Cannot describe".to_string(),
            error_code: "INVALID_TYPE".to_string(),
            fields: Some(vec!["Name".to_string()]),
        };
        let err = Error::DescribeError(resp);
        let display = format!("{}", err);
        assert!(display.contains("Error completing describe"));
    }

    #[test]
    fn test_display_login_error() {
        let resp = ErrorResponse {
            message: "Login failed".to_string(),
            error_code: "LOGIN_FAILED".to_string(),
            fields: None,
        };
        let err = Error::LoginError(resp);
        let display = format!("{}", err);
        assert!(display.contains("Error logging in"));
    }

    #[test]
    fn test_error_is_std_error() {
        let err = Error::NotLoggedIn;
        let _: &dyn std::error::Error = &err;
    }

    #[test]
    fn test_source_deserialize_error() {
        let json_err = serde_json::from_str::<String>("bad").unwrap_err();
        let err = Error::DeserializeError(json_err);
        assert!(StdError::source(&err).is_some());
    }

    #[test]
    fn test_source_header_error() {
        let header_err = reqwest::header::HeaderValue::from_str("\0").unwrap_err();
        let err = Error::HeaderError(header_err);
        assert!(StdError::source(&err).is_some());
    }

    #[test]
    fn test_source_none_for_other_variants() {
        assert!(StdError::source(&Error::NotLoggedIn).is_none());
        assert!(StdError::source(&Error::ConfigError("test".to_string())).is_none());
    }

    #[test]
    fn test_from_serde_json_error() {
        let json_err = serde_json::from_str::<String>("invalid json").unwrap_err();
        let err: Error = json_err.into();
        match err {
            Error::DeserializeError(_) => {}
            _ => panic!("Expected DeserializeError"),
        }
    }

    #[test]
    fn test_from_invalid_header_value() {
        let header_err = reqwest::header::HeaderValue::from_str("\0").unwrap_err();
        let err: Error = header_err.into();
        match err {
            Error::HeaderError(_) => {}
            _ => panic!("Expected HeaderError"),
        }
    }

    #[test]
    fn test_debug_impl() {
        let err = Error::NotLoggedIn;
        let debug = format!("{:?}", err);
        assert_eq!(debug, "NotLoggedIn");
    }
}