mailtrap 0.3.1

use anyhow::{Error, Result, anyhow};
use reqwest::{Client, Method, Url};
use serde::{Deserialize, Serialize, de::Deserializer, ser::Serializer};
use std::fmt::{self, Display};

/// Default base URL for the Mailtrap API.
const DEFAULT_URL: &str = "https://mailtrap.io";

/// Path for account access API endpoints.
const ACCESS_URL_PATH: &str = "/api/accounts";

/// Helper function to construct the access URL with the default base URL.
///
/// # Arguments
///
/// * `account_id` - The ID of the account.
/// * `domain_ids` - Optional list of domain IDs to filter by.
/// * `inbox_ids` - Optional list of inbox IDs to filter by.
/// * `project_ids` - Optional list of project IDs to filter by.
///
/// # Returns
///
/// Returns a `Result` containing a `Url` on success, or an `Error` on failure.
fn default_access_url_with_params(
    account_id: &str,
    domain_ids: Option<Vec<&str>>,
    inbox_ids: Option<Vec<&str>>,
    project_ids: Option<Vec<&str>>,
) -> Result<Url, Error> {
    if account_id.is_empty() {
        return Err(anyhow!("Account ID is empty"));
    }
    let url = DEFAULT_URL.trim_end_matches('/');
    let url = format!("{}{}/{}/account_access", url, ACCESS_URL_PATH, account_id);
    let mut url = Url::parse(&url)?;
    let mut params = Vec::<String>::new();
    if let Some(domain_ids) = domain_ids {
        params.push(format!("domain_ids=[{}]", domain_ids.join(",")));
    }
    if let Some(inbox_ids) = inbox_ids {
        params.push(format!("inbox_ids=[{}]", inbox_ids.join(",")));
    }
    if let Some(project_ids) = project_ids {
        params.push(format!("project_ids=[{}]", project_ids.join(",")));
    }
    if !params.is_empty() {
        url.set_query(Some(&params.join("&")));
    }
    Ok(url)
}

/// Helper function to construct the access URL with a custom base URL.
///
/// # Arguments
///
/// * `url` - The base URL of the API. A value of `None` will use the default base URL.
/// * `account_id` - The ID of the account.
/// * `domain_ids` - Optional list of domain IDs to filter by.
/// * `inbox_ids` - Optional list of inbox IDs to filter by.
/// * `project_ids` - Optional list of project IDs to filter by.
///
/// # Returns
///
/// Returns a `Result` containing a `Url` on success, or an `Error` on failure.
fn access_url_with_params(
    url: &str,
    account_id: &str,
    domain_ids: Option<Vec<&str>>,
    inbox_ids: Option<Vec<&str>>,
    project_ids: Option<Vec<&str>>,
) -> Result<Url, Error> {
    if url.is_empty() {
        return Err(anyhow!("URL is empty"));
    }
    if account_id.is_empty() {
        return Err(anyhow!("Account ID is empty"));
    }
    let url = url.trim_end_matches('/');
    let url = format!("{}{}/{}/account_access", url, ACCESS_URL_PATH, account_id);
    let mut url = Url::parse(&url)?;
    let mut params = Vec::<String>::new();
    if let Some(domain_ids) = domain_ids {
        params.push(format!("domain_ids=[{}]", domain_ids.join(",")));
    }
    if let Some(inbox_ids) = inbox_ids {
        params.push(format!("inbox_ids=[{}]", inbox_ids.join(",")));
    }
    if let Some(project_ids) = project_ids {
        params.push(format!("project_ids=[{}]", project_ids.join(",")));
    }
    if !params.is_empty() {
        url.set_query(Some(&params.join("&")));
    }
    Ok(url)
}

/// Helper function to construct the remove access URL with the default base URL.
///
/// # Arguments
///
/// * `account_id` - The ID of the account.
/// * `account_access_id` - The ID of the account access.
///
/// # Returns
///
/// Returns a `Result` containing a `Url` on success, or an `Error` on failure.
fn default_remove_access_url_with_params(
    account_id: &str,
    account_access_id: &str,
) -> Result<Url, Error> {
    if account_id.is_empty() {
        return Err(anyhow!("Account ID is empty"));
    }
    if account_access_id.is_empty() {
        return Err(anyhow!("Account access ID is empty"));
    }
    let url = DEFAULT_URL.trim_end_matches('/');
    let url = format!(
        "{}{}/{}/account_accesses/{}",
        url, ACCESS_URL_PATH, account_id, account_access_id
    );
    Ok(Url::parse(&url)?)
}

/// Helper function to construct the remove access URL with a custom base URL.
///
/// # Arguments
///
/// * `url` - The base URL of the API. A value of `None` will use the default base URL.
/// * `account_id` - The ID of the account.
/// * `account_access_id` - The ID of the account access.
///
/// # Returns
///
/// Returns a `Result` containing a `Url` on success, or an `Error` on failure.
fn remove_access_url_with_params(
    url: &str,
    account_id: &str,
    account_access_id: &str,
) -> Result<Url, Error> {
    if url.is_empty() {
        return Err(anyhow!("URL is empty"));
    }
    if account_id.is_empty() {
        return Err(anyhow!("Account ID is empty"));
    }
    if account_access_id.is_empty() {
        return Err(anyhow!("Account access ID is empty"));
    }
    let url = url.trim_end_matches('/');
    let url = format!(
        "{}{}/{}/account_accesses/{}",
        url, ACCESS_URL_PATH, account_id, account_access_id
    );
    Ok(Url::parse(&url)?)
}

/// Represents the type of entity that has access.
#[derive(Debug, Serialize, Deserialize, PartialEq)]
pub enum AccessSpecifierType {
    /// A regular user.
    User,
    /// An invited user.
    Invite,
    /// An API token.
    ApiToken,
}

impl AccessSpecifierType {
    /// Creates a new `AccessSpecifierType` from a string slice.
    ///
    /// # Arguments
    ///
    /// * `specifier_type` - The string representation of the specifier type ("user", "invite", or "api_token").
    pub fn new(specifier_type: &str) -> Result<Self, Error> {
        match specifier_type {
            "user" => Ok(Self::User),
            "invite" => Ok(Self::Invite),
            "api_token" => Ok(Self::ApiToken),
            _ => Err(anyhow!("Invalid specifier type: {}", specifier_type)),
        }
    }

    /// Returns the string representation of the specifier type.
    pub fn to_string(&self) -> String {
        match self {
            Self::User => "user".to_string(),
            Self::Invite => "invite".to_string(),
            Self::ApiToken => "api_token".to_string(),
        }
    }

    /// Creates a new `AccessSpecifierType` from a `String`.
    pub fn from_string(specifier_type: String) -> Result<Self, Error> {
        Self::new(&specifier_type.as_str())
    }

    /// Creates a new `AccessSpecifierType` from a string slice.
    pub fn from_str(specifier_type: &str) -> Result<Self, Error> {
        Self::new(specifier_type)
    }
}

impl Display for AccessSpecifierType {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}", self.to_string())
    }
}

/// Details about the entity holding the access.
#[derive(Debug, Serialize, Deserialize, PartialEq)]
pub struct AccessSpecifier {
    /// Unique identifier for the specifier.
    pub id: i64,
    /// Email address associated with the specifier.
    pub email: String,
    /// Name of the specifier.
    pub name: String,
    /// Whether two-factor authentication is enabled for this specifier.
    pub two_factor_authentication_enabled: bool,
}

/// Represents the type of resource being accessed.
#[derive(Debug, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum AccessResourceType {
    /// An account resource.
    Account,
    /// A billing resource.
    Billing,
    /// A project resource.
    Project,
    /// An inbox resource.
    Inbox,
    /// A sending domain resource.
    SendingDomain,
    /// An email campaign permission scope resource.
    EmailCampaignPermissionScope,
}

impl AccessResourceType {
    /// Creates a new `AccessResourceType` from a string slice.
    ///
    /// # Arguments
    ///
    /// * `resource_type` - The string representation of the resource type.
    pub fn new(resource_type: &str) -> Result<Self, Error> {
        match resource_type {
            "account" => Ok(Self::Account),
            "billing" => Ok(Self::Billing),
            "project" => Ok(Self::Project),
            "inbox" => Ok(Self::Inbox),
            "sending_domain" => Ok(Self::SendingDomain),
            "email_campaign_permission_scope" => Ok(Self::EmailCampaignPermissionScope),
            _ => Err(anyhow!("Invalid resource type: {}", resource_type)),
        }
    }

    /// Returns the string representation of the resource type.
    pub fn to_string(&self) -> String {
        match self {
            Self::Account => "account".to_string(),
            Self::Billing => "billing".to_string(),
            Self::Project => "project".to_string(),
            Self::Inbox => "inbox".to_string(),
            Self::SendingDomain => "sending_domain".to_string(),
            Self::EmailCampaignPermissionScope => "email_campaign_permission_scope".to_string(),
        }
    }

    /// Creates a new `AccessResourceType` from a `String`.
    pub fn from_string(resource_type: String) -> Result<Self, Error> {
        Self::new(&resource_type.as_str())
    }

    /// Creates a new `AccessResourceType` from a string slice.
    pub fn from_str(resource_type: &str) -> Result<Self, Error> {
        Self::new(resource_type)
    }
}

impl Display for AccessResourceType {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}", self.to_string())
    }
}

/// Represents the level of access granted to a resource.
#[derive(Debug, PartialEq)]
pub enum AccessResourceAccessLevel {
    /// Full ownership access (level 1000).
    Owner,
    /// Administrative access (level 100).
    Admin,
    /// Enhanced viewer access (level 50).
    ViewerPlus,
    /// Viewer access (level 10).
    Viewer,
    /// Indeterminate access level (level 1).
    Indeterminate,
}

impl AccessResourceAccessLevel {
    /// Creates a new `AccessResourceAccessLevel` from an integer value.
    ///
    /// # Arguments
    ///
    /// * `access_level` - The integer representation of the access level.
    pub fn new(access_level: i64) -> Result<Self, Error> {
        match access_level {
            1000 => Ok(Self::Owner),
            100 => Ok(Self::Admin),
            50 => Ok(Self::ViewerPlus),
            10 => Ok(Self::Viewer),
            1 => Ok(Self::Indeterminate),
            _ => Err(anyhow!("Invalid access level: {}", access_level)),
        }
    }

    /// Returns the integer representation of the access level.
    pub fn to_int(&self) -> i64 {
        match self {
            Self::Owner => 1000,
            Self::Admin => 100,
            Self::ViewerPlus => 50,
            Self::Viewer => 10,
            Self::Indeterminate => 1,
        }
    }

    /// Creates a new `AccessResourceAccessLevel` from an integer.
    pub fn from_int(access_level: i64) -> Result<Self, Error> {
        Self::new(access_level)
    }

    /// Returns the string representation of the access level.
    pub fn to_string(&self) -> String {
        match self {
            Self::Owner => "owner".to_string(),
            Self::Admin => "admin".to_string(),
            Self::ViewerPlus => "viewer_plus".to_string(),
            Self::Viewer => "viewer".to_string(),
            Self::Indeterminate => "indeterminate".to_string(),
        }
    }

    /// Creates a new `AccessResourceAccessLevel` from a string representation of the integer value.
    pub fn from_string(access_level: String) -> Result<Self, Error> {
        let access_level = access_level.parse::<i64>()?;
        Self::new(access_level)
    }

    /// Creates a new `AccessResourceAccessLevel` from a string slice representation of the integer value.
    pub fn from_str(access_level: &str) -> Result<Self, Error> {
        let access_level = access_level.parse::<i64>()?;
        Self::new(access_level)
    }
}

impl Display for AccessResourceAccessLevel {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}", self.to_string())
    }
}

impl Serialize for AccessResourceAccessLevel {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        serializer.serialize_i64(self.to_int())
    }
}

impl<'de> Deserialize<'de> for AccessResourceAccessLevel {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        let access_level = i64::deserialize(deserializer)?;
        Self::new(access_level).map_err(serde::de::Error::custom)
    }
}
/// Represents a specific resource and the access level granted to it.
#[derive(Debug, Serialize, Deserialize, PartialEq)]
pub struct AccessResource {
    /// The ID of the resource.
    pub resource_id: i64,
    /// The type of the resource.
    pub resource_type: AccessResourceType,
    /// The level of access granted to this resource.
    pub access_level: AccessResourceAccessLevel,
}

/// Defines specific permissions granted.
#[derive(Debug, Serialize, Deserialize, PartialEq)]
pub struct AccessPermission {
    /// Whether read access is granted.
    pub can_read: bool,
    /// Whether update access is granted.
    pub can_update: bool,
    /// Whether delete/destroy access is granted.
    pub can_destroy: bool,
    /// Whether the user can leave the resource.
    pub can_leave: bool,
}

/// Represents a complete access record returned by the API.
#[derive(Debug, Serialize, Deserialize, PartialEq)]
pub struct AccessRecord {
    /// Unique identifier for the access record.
    pub id: i64,
    /// The type of the specifier (user, invite, etc.).
    pub specifier_type: AccessSpecifierType,
    /// Detailed information about the specifier.
    pub specifier: AccessSpecifier,
    /// List of resources associated with this access record.
    pub resources: Vec<AccessResource>,
    /// Specific permissions granted.
    pub permissions: AccessPermission,
}

/// Represents an error response from the API with a single error message.
#[derive(Debug, Serialize, Deserialize, PartialEq)]
pub struct AccessErrorResponse {
    /// The error message.
    pub error: String,
}

/// Represents an error response from the API with multiple error messages.
#[derive(Debug, Serialize, Deserialize, PartialEq)]
pub struct AccessErrorsResponse {
    /// List of error messages.
    pub errors: Vec<String>,
}

/// Represents the response from removing an access record.
#[derive(Debug, Serialize, Deserialize, PartialEq)]
pub struct AccessRemoveResponse {
    /// The ID of the removed access record.
    pub id: i64,
}

/// Client for interacting with the Mailtrap Access API.
#[derive(Debug, PartialEq, Clone)]
pub struct Access {}

impl Access {
    /// Creates a new `Access` client instance.
    pub fn new() -> Self {
        Self {}
    }

    /// Lists access records for a given account.
    ///
    /// # Arguments
    ///
    /// * `api_url` - Optional custom API URL. A value of `None` will use the default base URL.
    /// * `api_key` - Optional API key for authentication.
    /// * `bearer_token` - Optional Bearer token for authentication.
    /// * `account_id` - The ID of the account to list access for.
    /// * `domain_ids` - Optional list of domain IDs to filter by.
    /// * `inbox_ids` - Optional list of inbox IDs to filter by.
    /// * `project_ids` - Optional list of project IDs to filter by.
    ///
    /// # Returns
    ///
    /// Returns a `Result` containing a vector of `AccessRecord`s on success, or an `Error` on failure.
    pub async fn list(
        &self,
        api_url: Option<&str>,
        api_key: Option<&str>,
        bearer_token: Option<&str>,
        account_id: &str,
        domain_ids: Option<Vec<&str>>,
        inbox_ids: Option<Vec<&str>>,
        project_ids: Option<Vec<&str>>,
    ) -> Result<Vec<AccessRecord>, Error> {
        if api_key.is_none() && bearer_token.is_none() {
            return Err(anyhow!("API key or bearer token is required"));
        }
        if api_key.is_some_and(|key| key.is_empty()) {
            return Err(anyhow!("API key is empty"));
        }
        if bearer_token.is_some_and(|token| token.is_empty()) {
            return Err(anyhow!("Bearer token is empty"));
        }

        if account_id.is_empty() {
            return Err(anyhow!("Account ID is empty"));
        }

        if domain_ids.clone().is_some() {
            if domain_ids.clone().unwrap().is_empty() {
                return Err(anyhow!("Domain IDs are empty"));
            }
            for id in domain_ids.clone().unwrap() {
                if id.is_empty() {
                    return Err(anyhow!("Domain IDs are empty"));
                }
            }
        }
        if inbox_ids.clone().is_some() {
            if inbox_ids.clone().unwrap().is_empty() {
                return Err(anyhow!("Inbox IDs are empty"));
            }
            for id in inbox_ids.clone().unwrap() {
                if id.is_empty() {
                    return Err(anyhow!("Inbox IDs are empty"));
                }
            }
        }
        if project_ids.clone().is_some() {
            if project_ids.clone().unwrap().is_empty() {
                return Err(anyhow!("Project IDs are empty"));
            }
            for id in project_ids.clone().unwrap() {
                if id.is_empty() {
                    return Err(anyhow!("Project IDs are empty"));
                }
            }
        }

        let url = match api_url {
            Some(url) => {
                if url.is_empty() {
                    return Err(anyhow!("URL is empty"));
                }
                let url = Url::parse(url).map_err(|e| anyhow!("Failed to parse URL: {}", e))?;
                access_url_with_params(
                    url.as_str(),
                    account_id,
                    domain_ids,
                    inbox_ids,
                    project_ids,
                )?
            }
            None => default_access_url_with_params(account_id, domain_ids, inbox_ids, project_ids)?,
        };

        let client = Client::new();
        let mut request = client.request(Method::GET, url.clone());

        if api_key.is_some() {
            request = request.header("Api-Token", api_key.unwrap());
        }

        if bearer_token.is_some() {
            request = request.header("Authorization", format!("Bearer {}", bearer_token.unwrap()));
        }

        let response = match request.send().await {
            Ok(response) => response,
            Err(e) => return Err(anyhow!("Failed to get access list: {}", e)),
        };

        let status = response.status();

        if !status.is_success() {
            match status.as_u16() {
                401 => {
                    let body = match response.json::<AccessErrorResponse>().await {
                        Ok(body) => body,
                        Err(e) => return Err(anyhow!("Failed to parse response: {}", e)),
                    };
                    return Err(anyhow!("Failed to get access list: {}", body.error));
                }
                403 => {
                    let body = match response.json::<AccessErrorsResponse>().await {
                        Ok(body) => body,
                        Err(e) => return Err(anyhow!("Failed to parse response: {}", e)),
                    };
                    return Err(anyhow!(
                        "Failed to get access list: {}",
                        body.errors.join(": ")
                    ));
                }
                _ => return Err(anyhow!("Failed to get access list: {}", status)),
            }
        }

        match response.json::<Vec<AccessRecord>>().await {
            Ok(body) => Ok(body),
            Err(e) => Err(anyhow!("Failed to parse response: {}", e)),
        }
    }

    /// Removes an access record for a given account.
    ///
    /// # Arguments
    ///
    /// * `api_url` - Optional custom API URL. A value of `None` will use the default base URL.
    /// * `api_key` - Optional API key for authentication.
    /// * `bearer_token` - Optional Bearer token for authentication.
    /// * `account_id` - The ID of the account to remove access for.
    /// * `account_access_id` - The ID of the account access to remove.
    ///
    /// # Returns
    ///
    /// Returns a `Result` containing a `AccessRemoveResponse` on success, or an `Error` on failure.
    pub async fn remove(
        &self,
        api_url: Option<&str>,
        api_key: Option<&str>,
        bearer_token: Option<&str>,
        account_id: &str,
        account_access_id: &str,
    ) -> Result<AccessRemoveResponse, Error> {
        if api_key.is_none() && bearer_token.is_none() {
            return Err(anyhow!("API key or bearer token is required"));
        }
        if api_key.is_some_and(|key| key.is_empty()) {
            return Err(anyhow!("API key is empty"));
        }
        if bearer_token.is_some_and(|token| token.is_empty()) {
            return Err(anyhow!("Bearer token is empty"));
        }
        if account_id.is_empty() {
            return Err(anyhow!("Account ID is empty"));
        }
        if account_access_id.is_empty() {
            return Err(anyhow!("Account access ID is empty"));
        }

        let url = match api_url {
            Some(url) => {
                if url.is_empty() {
                    return Err(anyhow!("URL is empty"));
                }
                let url = Url::parse(url).map_err(|e| anyhow!("Failed to parse URL: {}", e))?;
                remove_access_url_with_params(url.as_str(), account_id, account_access_id)?
            }
            None => default_remove_access_url_with_params(account_id, account_access_id)?,
        };

        let client = Client::new();
        let mut request = client.request(Method::DELETE, url.clone());

        if api_key.is_some() {
            request = request.header("Api-Token", api_key.unwrap());
        }

        if bearer_token.is_some() {
            request = request.header("Authorization", format!("Bearer {}", bearer_token.unwrap()));
        }

        let response = match request.send().await {
            Ok(response) => response,
            Err(e) => return Err(anyhow!("Failed to remove access: {}", e)),
        };

        let status = response.status();

        if !status.is_success() {
            match status.as_u16() {
                401 => {
                    let body = match response.json::<AccessErrorResponse>().await {
                        Ok(body) => body,
                        Err(e) => return Err(anyhow!("Failed to parse response: {}", e)),
                    };
                    return Err(anyhow!("Failed to remove access: {}", body.error));
                }
                403 => {
                    let body = match response.json::<AccessErrorsResponse>().await {
                        Ok(body) => body,
                        Err(e) => return Err(anyhow!("Failed to parse response: {}", e)),
                    };
                    return Err(anyhow!(
                        "Failed to remove access: {}",
                        body.errors.join(": ")
                    ));
                }
                404 => {
                    let body = match response.json::<AccessErrorResponse>().await {
                        Ok(body) => body,
                        Err(e) => return Err(anyhow!("Failed to parse response: {}", e)),
                    };
                    return Err(anyhow!("Failed to remove access: {}", body.error));
                }
                _ => return Err(anyhow!("Failed to remove access: {}", status)),
            }
        }
        match response.json::<AccessRemoveResponse>().await {
            Ok(body) => Ok(body),
            Err(e) => Err(anyhow!("Failed to parse response: {}", e)),
        }
    }
}

#[cfg(test)]
mod test {
    use super::*;

    #[test]
    fn test_default_access_url_fails_with_empty_account_id() {
        let url = default_access_url_with_params("", None, None, None);
        assert_eq!(url.is_err(), true);
        assert_eq!(url.unwrap_err().to_string(), "Account ID is empty");
    }

    #[test]
    fn test_default_access_url_with_params() {
        let url = default_access_url_with_params(
            "1234567890",
            Some(vec!["1234567890"]),
            Some(vec!["1234567890"]),
            Some(vec!["1234567890"]),
        );
        assert_eq!(url.is_ok(), true);
        assert_eq!(
            url.unwrap().to_string(),
            "https://mailtrap.io/api/accounts/1234567890/account_access?domain_ids=[1234567890]&inbox_ids=[1234567890]&project_ids=[1234567890]"
        );
    }

    #[test]
    fn test_access_url_fails_with_empty_url() {
        let url = access_url_with_params("", "1234567890", None, None, None);
        assert_eq!(url.is_err(), true);
        assert_eq!(url.unwrap_err().to_string(), "URL is empty");
    }

    #[test]
    fn test_access_url_with_params() {
        let url = access_url_with_params(
            "https://mailtrap.io/",
            "1234567890",
            Some(vec!["1234567890"]),
            Some(vec!["1234567890"]),
            Some(vec!["1234567890"]),
        );
        assert_eq!(url.is_ok(), true);
        assert_eq!(
            url.unwrap().to_string(),
            "https://mailtrap.io/api/accounts/1234567890/account_access?domain_ids=[1234567890]&inbox_ids=[1234567890]&project_ids=[1234567890]"
        );
    }

    #[test]
    fn test_default_remove_access_url_fails_with_empty_account_id() {
        let url = default_remove_access_url_with_params("", "1234567890");
        assert_eq!(url.is_err(), true);
        assert_eq!(url.unwrap_err().to_string(), "Account ID is empty");
    }

    #[test]
    fn test_default_remove_access_url_fails_with_empty_account_access_id() {
        let url = default_remove_access_url_with_params("1234567890", "");
        assert_eq!(url.is_err(), true);
        assert_eq!(url.unwrap_err().to_string(), "Account access ID is empty");
    }

    #[test]
    fn test_default_remove_access_url_with_params() {
        let url = default_remove_access_url_with_params("1234567890", "1234567890");
        assert_eq!(url.is_ok(), true);
        assert_eq!(
            url.unwrap().to_string(),
            "https://mailtrap.io/api/accounts/1234567890/account_accesses/1234567890"
        );
    }

    #[test]
    fn test_remove_access_url_fails_with_empty_url() {
        let url = remove_access_url_with_params("", "1234567890", "1234567890");
        assert_eq!(url.is_err(), true);
        assert_eq!(url.unwrap_err().to_string(), "URL is empty");
    }

    #[test]
    fn test_remove_access_url_fails_with_empty_account_id() {
        let url = remove_access_url_with_params("https://mailtrap.io/", "", "1234567890");
        assert_eq!(url.is_err(), true);
        assert_eq!(url.unwrap_err().to_string(), "Account ID is empty");
    }

    #[test]
    fn test_remove_access_url_fails_with_empty_account_access_id() {
        let url = remove_access_url_with_params("https://mailtrap.io/", "1234567890", "");
        assert_eq!(url.is_err(), true);
        assert_eq!(url.unwrap_err().to_string(), "Account access ID is empty");
    }

    #[test]
    fn test_remove_access_url_succeeds() {
        let url = remove_access_url_with_params("https://mailtrap.io/", "1234567890", "1234567890");
        assert_eq!(url.is_ok(), true);
        assert_eq!(
            url.unwrap().to_string(),
            "https://mailtrap.io/api/accounts/1234567890/account_accesses/1234567890"
        );
    }
}