attune-core 0.1.0

use serde::{Serialize, de::DeserializeOwned};

use crate::SettingsError;

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct StoredValue(String);

impl StoredValue {
    /// Given a reference to a value of type T, return it as a StoredValue instance with the
    /// original value JSON encoded.
    pub fn encode<T: Serialize>(value: &T) -> Result<StoredValue, SettingsError> {
        let encoding =
            serde_json::to_string(value).map_err(|source| SettingsError::Serialize { source })?;
        let sv = StoredValue(encoding);
        Ok(sv)
    }

    // Decode StoredValue into its original value of type T.
    pub fn decode<T: DeserializeOwned>(&self) -> Result<T, serde_json::Error> {
        let v = serde_json::from_str(&self.0)?;
        Ok(v)
    }

    // Converts a StoredValue to a String.
    pub fn as_str(&self) -> &str {
        &self.0
    }

    /// Wrap a raw, JSON-encoded string as a Stored Value. For use by backends
    /// that read pre-serialized values from persistent storage. The caller is
    /// responsible for ensuring the string is valid JSON.
    pub fn from_raw(serialized: String) -> StoredValue {
        StoredValue(serialized)
    }
}

#[cfg(test)]
mod test {

    use super::*;

    #[test]
    fn test_encode_returns_sv_with_encoded_string() {
        let sv_res = StoredValue::encode(&String::from("test"));
        assert!(sv_res.is_ok());

        let sv = sv_res.unwrap();
        assert_eq!(sv.0, "\"test\"")
    }

    #[test]
    fn test_encode_gracefully_handle_error() {
        let test_str = "test";
        let sv = StoredValue::encode(&test_str).unwrap();
        let decoded_val: String = sv.decode().unwrap();

        assert_eq!(decoded_val, test_str)
    }

    #[test]
    fn test_as_str_returns_non_str_value_as_str() {
        let test_val = 100;
        let sv = StoredValue::encode(&test_val).unwrap();
        let test_val_str = sv.as_str();

        assert_eq!(test_val_str, test_val.to_string())
    }
}