microsandbox-core 0.2.6

use crate::MicrosandboxError;
use getset::Getters;
use serde::{Deserialize, Serialize};
use std::{fmt, str::FromStr};

//--------------------------------------------------------------------------------------------------
// Types
//--------------------------------------------------------------------------------------------------

/// Represents an environment variable pair.
///
/// This struct encapsulates a variable name and its corresponding value.
/// It is used to manage environment variables for processes.
///
/// ## Examples
///
/// ```
/// use microsandbox_core::config::EnvPair;
/// use std::str::FromStr;
///
/// // Create a new environment variable pair
/// let env_pair = EnvPair::new("PATH", "/usr/local/bin:/usr/bin");
///
/// assert_eq!(env_pair.get_name(), "PATH");
/// assert_eq!(env_pair.get_value(), "/usr/local/bin:/usr/bin");
///
/// // Parse an environment variable pair from a string
/// let env_pair = EnvPair::from_str("USER=alice").unwrap();
///
/// assert_eq!(env_pair.get_name(), "USER");
/// assert_eq!(env_pair.get_value(), "alice");
/// ```
#[derive(Debug, Hash, Clone, PartialEq, Eq, Getters)]
#[getset(get = "pub with_prefix")]
pub struct EnvPair {
    /// The environment variable name.
    name: String,

    /// The value of the environment variable.
    value: String,
}

//--------------------------------------------------------------------------------------------------
// Methods
//--------------------------------------------------------------------------------------------------

impl EnvPair {
    /// Creates a new `EnvPair` with the given variable name and value.
    ///
    /// # Arguments
    ///
    /// * `var` - The name of the environment variable.
    /// * `value` - The value of the environment variable.
    ///
    /// ## Examples
    ///
    /// ```
    /// use microsandbox_core::config::EnvPair;
    ///
    /// let env_pair = EnvPair::new("HOME", "/home/user");
    /// assert_eq!(env_pair.get_name(), "HOME");
    /// assert_eq!(env_pair.get_value(), "/home/user");
    /// ```
    pub fn new<S: Into<String>>(name: S, value: S) -> Self {
        Self {
            name: name.into(),
            value: value.into(),
        }
    }
}

//--------------------------------------------------------------------------------------------------
// Trait Implementations
//--------------------------------------------------------------------------------------------------

impl FromStr for EnvPair {
    type Err = MicrosandboxError;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        let (var, value) = s
            .split_once('=')
            .ok_or_else(|| MicrosandboxError::InvalidEnvPair(s.to_string()))?;

        if var.is_empty() {
            return Err(MicrosandboxError::InvalidEnvPair(s.to_string()));
        }

        Ok(Self::new(var, value))
    }
}

impl fmt::Display for EnvPair {
    /// Formats the environment variable pair following the format "<var>=<value>".
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}={}", self.name, self.value)
    }
}

impl Serialize for EnvPair {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        serializer.serialize_str(&self.to_string())
    }
}

impl<'de> Deserialize<'de> for EnvPair {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        let s = String::deserialize(deserializer)?;
        Self::from_str(&s).map_err(serde::de::Error::custom)
    }
}

//--------------------------------------------------------------------------------------------------
// Tests
//--------------------------------------------------------------------------------------------------

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

    #[test]
    fn test_env_pair_new() {
        let env_pair = EnvPair::new("VAR", "VALUE");
        assert_eq!(env_pair.name, String::from("VAR"));
        assert_eq!(env_pair.value, String::from("VALUE"));
    }

    #[test]
    fn test_env_pair_from_str() -> anyhow::Result<()> {
        let env_pair: EnvPair = "VAR=VALUE".parse()?;
        assert_eq!(env_pair.name, String::from("VAR"));
        assert_eq!(env_pair.value, String::from("VALUE"));

        let env_pair: EnvPair = "VAR=".parse()?;
        assert_eq!(env_pair.name, String::from("VAR"));
        assert_eq!(env_pair.value, String::from(""));

        assert!("VAR".parse::<EnvPair>().is_err());
        assert!("=VALUE".parse::<EnvPair>().is_err());

        Ok(())
    }

    #[test]
    fn test_env_pair_display() {
        let env_pair = EnvPair::new("VAR", "VALUE");
        assert_eq!(env_pair.to_string(), "VAR=VALUE");

        let env_pair = EnvPair::new("VAR", "");
        assert_eq!(env_pair.to_string(), "VAR=");
    }

    #[test]
    fn test_env_pair_serialize_deserialize() -> anyhow::Result<()> {
        let env_pair = EnvPair::new("VAR", "VALUE");
        let serialized = serde_json::to_string(&env_pair)?;
        assert_eq!(serialized, "\"VAR=VALUE\"");

        let deserialized: EnvPair = serde_json::from_str(&serialized)?;
        assert_eq!(deserialized, env_pair);

        let env_pair = EnvPair::new("VAR", "");
        let serialized = serde_json::to_string(&env_pair)?;
        assert_eq!(serialized, "\"VAR=\"");

        let deserialized: EnvPair = serde_json::from_str(&serialized)?;
        assert_eq!(deserialized, env_pair);

        Ok(())
    }

    #[test]
    fn test_env_pair_with_special_characters() -> anyhow::Result<()> {
        let env_pair: EnvPair = "VAR_WITH_UNDERSCORE=VALUE WITH SPACES".parse()?;
        assert_eq!(env_pair.name, "VAR_WITH_UNDERSCORE");
        assert_eq!(env_pair.value, "VALUE WITH SPACES");

        let env_pair: EnvPair = "VAR.WITH.DOTS=VALUE_WITH_UNDERSCORE".parse()?;
        assert_eq!(env_pair.name, "VAR.WITH.DOTS");
        assert_eq!(env_pair.value, "VALUE_WITH_UNDERSCORE");

        Ok(())
    }
}