libdolly-rs 0.1.0

use base64::{Engine as _, engine::general_purpose};
use tower_sessions::cookie::Key;

pub struct SessionKey {
    key: Vec<u8>,
}

impl SessionKey {
    pub fn new() -> Self {
        let key = Key::generate().master().to_vec();
        Self { key }
    }

    pub fn as_bytes(&self) -> &[u8] {
        &self.key
    }

    pub fn print_encoded(&self) {
        println!("{:?}", general_purpose::STANDARD.encode(&self.key));
    }
}

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

    #[test]
    fn test_session_key_new() {
        let session_key = SessionKey::new();
        // tower_sessions Key::generate() produces a 64-byte key
        assert_eq!(session_key.key.len(), 64);
    }

    #[test]
    fn test_session_key_as_bytes() {
        let session_key = SessionKey::new();
        let bytes = session_key.as_bytes();

        // Verify that as_bytes returns the same data as the internal key
        assert_eq!(bytes.len(), 64);
        assert_eq!(bytes, session_key.key.as_slice());
    }

    #[test]
    fn test_session_key_uniqueness() {
        let key1 = SessionKey::new();
        let key2 = SessionKey::new();

        // Each generated key should be unique
        assert_ne!(key1.as_bytes(), key2.as_bytes());
    }

    #[test]
    fn test_encoded_key_is_valid_base64() {
        let session_key = SessionKey::new();
        let encoded = general_purpose::STANDARD.encode(&session_key.key);

        // Verify the encoded string is valid base64 and can be decoded
        let decoded = general_purpose::STANDARD.decode(&encoded).unwrap();
        assert_eq!(decoded, session_key.key);
    }

    #[test]
    fn test_encoded_key_length() {
        let session_key = SessionKey::new();
        let encoded = general_purpose::STANDARD.encode(&session_key.key);

        // Base64 encoding of 64 bytes should produce 88 characters (with padding)
        // Formula: ceil(64 * 4/3) = 86, rounded up to multiple of 4 = 88
        assert_eq!(encoded.len(), 88);
    }

    #[test]
    fn test_multiple_keys_produce_different_encodings() {
        let key1 = SessionKey::new();
        let key2 = SessionKey::new();

        let encoded1 = general_purpose::STANDARD.encode(&key1.key);
        let encoded2 = general_purpose::STANDARD.encode(&key2.key);

        assert_ne!(encoded1, encoded2);
    }
}