Skip to content

armgit / macro

Public Imported from GitHub
0

Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.

12.3 KB
Raw Blame
use std::collections::HashMap;
use std::sync::{Arc, Mutex};

use chrono::Utc;
use macro_user_id::user_id::MacroUserIdStr;

use super::{MAX_KEYS_PER_USER, UserApiKeyServiceImpl};
use sha2::Digest;

use crate::domain::models::{
    CreatedUserApiKey, MAX_KEY_NAME_LEN, UserApiKey, UserApiKeyError, UserApiKeyId, UserApiKeyInfo,
    hash_key,
};
use crate::domain::ports::{UserApiKeyService, UserApiKeysRepo};

const USER_A: &str = "macro|[email protected]";
const USER_B: &str = "macro|[email protected]";

fn user(id: &str) -> MacroUserIdStr<'_> {
    MacroUserIdStr::parse_from_str(id).expect("valid user id")
}

#[derive(Clone)]
struct StoredKey {
    id: UserApiKeyId,
    name: String,
    created_at: chrono::DateTime<Utc>,
    hash: [u8; 32],
}

#[derive(Clone, Default)]
struct FakeUserApiKeysRepo {
    keys: Arc<Mutex<HashMap<String, Vec<StoredKey>>>>,
    fail: bool,
}

#[derive(Debug, thiserror::Error)]
#[error("fake user api key repository error")]
struct FakeRepoError;

impl FakeUserApiKeysRepo {
    fn with_count(user_id: &str, count: usize) -> Self {
        let repo = Self::default();
        {
            let mut keys = repo.keys.lock().expect("keys lock poisoned");
            let set = keys.entry(user_id.to_string()).or_default();
            for i in 0..count {
                set.push(StoredKey {
                    id: UserApiKeyId::generate(),
                    name: format!("seed-{i}"),
                    created_at: Utc::now(),
                    hash: hash_key(&format!("seed-key-{i}")),
                });
            }
        }
        repo
    }

    fn stored_hashes_for(&self, user_id: &str) -> Vec<[u8; 32]> {
        self.keys
            .lock()
            .expect("keys lock poisoned")
            .get(user_id)
            .map(|keys| keys.iter().map(|k| k.hash).collect())
            .unwrap_or_default()
    }
}

impl UserApiKeysRepo for FakeUserApiKeysRepo {
    type Err = FakeRepoError;

    async fn insert_key(
        &self,
        user_id: &MacroUserIdStr<'_>,
        id: UserApiKeyId,
        name: &str,
        hash: &[u8; 32],
    ) -> Result<UserApiKeyInfo, Self::Err> {
        if self.fail {
            return Err(FakeRepoError);
        }
        let info = UserApiKeyInfo {
            id,
            name: name.to_string(),
            created_at: Utc::now(),
        };
        self.keys
            .lock()
            .expect("keys lock poisoned")
            .entry(user_id.as_ref().to_string())
            .or_default()
            .push(StoredKey {
                id,
                name: name.to_string(),
                created_at: info.created_at,
                hash: *hash,
            });
        Ok(info)
    }

    async fn count_keys(&self, user_id: &MacroUserIdStr<'_>) -> Result<i64, Self::Err> {
        if self.fail {
            return Err(FakeRepoError);
        }
        Ok(self.stored_hashes_for(user_id.as_ref()).len() as i64)
    }

    async fn list_keys(
        &self,
        user_id: &MacroUserIdStr<'_>,
    ) -> Result<Vec<UserApiKeyInfo>, Self::Err> {
        if self.fail {
            return Err(FakeRepoError);
        }
        Ok(self
            .keys
            .lock()
            .expect("keys lock poisoned")
            .get(user_id.as_ref())
            .map(|keys| {
                keys.iter()
                    .map(|k| UserApiKeyInfo {
                        id: k.id,
                        name: k.name.clone(),
                        created_at: k.created_at,
                    })
                    .collect()
            })
            .unwrap_or_default())
    }

    async fn replace_keys_named(
        &self,
        user_id: &MacroUserIdStr<'_>,
        id: UserApiKeyId,
        name: &str,
        hash: &[u8; 32],
    ) -> Result<UserApiKeyInfo, Self::Err> {
        self.keys
            .lock()
            .expect("keys lock poisoned")
            .entry(user_id.as_ref().to_string())
            .or_default()
            .retain(|stored| stored.name != name);
        self.insert_key(user_id, id, name, hash).await
    }

    async fn delete_key(
        &self,
        user_id: &MacroUserIdStr<'_>,
        id: UserApiKeyId,
    ) -> Result<bool, Self::Err> {
        if self.fail {
            return Err(FakeRepoError);
        }
        let mut keys = self.keys.lock().expect("keys lock poisoned");
        let Some(set) = keys.get_mut(user_id.as_ref()) else {
            return Ok(false);
        };
        let before = set.len();
        set.retain(|stored| stored.id != id);
        Ok(set.len() < before)
    }

    async fn find_user_id_by_key(
        &self,
        key: &UserApiKey,
    ) -> Result<Option<MacroUserIdStr<'static>>, Self::Err> {
        if self.fail {
            return Err(FakeRepoError);
        }
        let hash = key.hash();
        let keys = self.keys.lock().expect("keys lock poisoned");
        for (user_id, set) in keys.iter() {
            if set.iter().any(|stored| stored.hash == hash) {
                return Ok(Some(
                    MacroUserIdStr::try_from(user_id.clone()).expect("valid user id"),
                ));
            }
        }
        Ok(None)
    }
}

fn looks_like_generated_key(key: &str) -> bool {
    key.starts_with("mak_")
        && key.len() == "mak_".len() + 64
        && key[4..].chars().all(|ch| ch.is_ascii_hexdigit())
}

#[tokio::test]
async fn create_key_returns_secret_once_and_stores_hash() {
    let repo = FakeUserApiKeysRepo::default();
    let service = UserApiKeyServiceImpl::new(repo.clone());

    let created = service
        .create_key(&user(USER_A), " Laptop ")
        .await
        .expect("create should succeed");
    assert_eq!(created.name, "Laptop");
    assert!(created.created_at <= Utc::now());
    assert!(looks_like_generated_key(&created.key));
    assert!(
        repo.stored_hashes_for(USER_A)
            .contains(&UserApiKey::from_raw(&created.key).hash())
    );
}

#[tokio::test]
async fn create_key_returns_distinct_secrets() {
    let service = UserApiKeyServiceImpl::new(FakeUserApiKeysRepo::default());

    let first = service
        .create_key(&user(USER_A), "one")
        .await
        .expect("first create");
    let second = service
        .create_key(&user(USER_A), "two")
        .await
        .expect("second create");
    assert_ne!(first.key, second.key);
    assert_ne!(first.id, second.id);
}

#[tokio::test]
async fn create_key_rejects_empty_or_too_long_name() {
    let service = UserApiKeyServiceImpl::new(FakeUserApiKeysRepo::default());

    let empty = service
        .create_key(&user(USER_A), "   ")
        .await
        .expect_err("empty name should reject");
    assert!(matches!(empty, UserApiKeyError::BadRequest(_)));

    let too_long = "x".repeat(MAX_KEY_NAME_LEN + 1);
    let err = service
        .create_key(&user(USER_A), &too_long)
        .await
        .expect_err("long name should reject");
    assert!(matches!(err, UserApiKeyError::BadRequest(_)));
}

#[tokio::test]
async fn create_key_rejects_at_cap() {
    let service =
        UserApiKeyServiceImpl::new(FakeUserApiKeysRepo::with_count(USER_A, MAX_KEYS_PER_USER));

    let err = service
        .create_key(&user(USER_A), "overflow")
        .await
        .expect_err("cap should reject");
    match err {
        UserApiKeyError::BadRequest(message) => {
            assert!(message.contains(&MAX_KEYS_PER_USER.to_string()));
        }
        other => panic!("expected BadRequest, got {other:?}"),
    }
}

#[tokio::test]
async fn list_keys_returns_id_name_and_created_at() {
    let service = UserApiKeyServiceImpl::new(FakeUserApiKeysRepo::default());

    let created_a = service
        .create_key(&user(USER_A), "A key")
        .await
        .expect("create for A");
    let created_b = service
        .create_key(&user(USER_B), "B key")
        .await
        .expect("create for B");

    let a_keys = service.list_keys(&user(USER_A)).await.expect("list A");
    let b_keys = service.list_keys(&user(USER_B)).await.expect("list B");
    assert_eq!(a_keys.len(), 1);
    assert_eq!(b_keys.len(), 1);
    assert_eq!(a_keys[0].id, created_a.id);
    assert_eq!(a_keys[0].name, "A key");
    assert_eq!(a_keys[0].created_at, created_a.created_at);
    assert_ne!(a_keys[0].id, created_b.id);
    let listed = serde_json::to_string(&a_keys[0]).expect("list json");
    assert!(!listed.contains(&created_a.key));
    assert!(!listed.contains("hash"));
}

#[tokio::test]
async fn delete_key_removes_by_id() {
    let service = UserApiKeyServiceImpl::new(FakeUserApiKeysRepo::default());
    let created = service
        .create_key(&user(USER_A), "to-delete")
        .await
        .expect("create should succeed");

    service
        .delete_key(&user(USER_A), created.id)
        .await
        .expect("delete should succeed");

    let err = service
        .delete_key(&user(USER_A), created.id)
        .await
        .expect_err("second delete should miss");
    assert!(matches!(err, UserApiKeyError::NotFound));
}

#[tokio::test]
async fn delete_key_does_not_remove_another_users_id() {
    let service = UserApiKeyServiceImpl::new(FakeUserApiKeysRepo::default());
    let created = service
        .create_key(&user(USER_A), "owned-by-a")
        .await
        .expect("create for A");

    let err = service
        .delete_key(&user(USER_B), created.id)
        .await
        .expect_err("B must not delete A's key");
    assert!(matches!(err, UserApiKeyError::NotFound));
}

#[tokio::test]
async fn repo_failure_is_internal() {
    let service = UserApiKeyServiceImpl::new(FakeUserApiKeysRepo {
        fail: true,
        ..FakeUserApiKeysRepo::default()
    });

    let err = service
        .create_key(&user(USER_A), "fail")
        .await
        .expect_err("failure should surface");
    assert!(matches!(err, UserApiKeyError::Internal(_)));
}

#[test]
fn debug_does_not_contain_full_secret() {
    let key = UserApiKey::from_raw(
        "mak_0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef",
    );
    let debug = format!("{key:?}");
    assert!(!debug.contains(key.expose()));
    assert!(debug.starts_with("mak_…"));
    assert!(debug.ends_with("cdef"));
}

#[test]
fn hash_key_matches_sha256_of_utf8_bytes() {
    let key = UserApiKey::from_raw("mak_secret");
    let expected: [u8; 32] = sha2::Sha256::digest(b"mak_secret").into();
    assert_eq!(key.hash(), expected);
    assert_ne!(hash_key("mak_secret"), hash_key("mak_other"));
}

#[test]
fn list_metadata_json_is_id_name_and_created_at() {
    let key = UserApiKey::from_raw(
        "mak_0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef",
    );
    let info = UserApiKeyInfo {
        id: UserApiKeyId::generate(),
        name: "CI".to_string(),
        created_at: Utc::now(),
    };
    let json = serde_json::to_value(&info).expect("serialize info");
    assert!(json.get("key").is_none());
    assert!(json.get("hash").is_none());
    assert!(json.get("prefix").is_none());
    assert!(json.get("id").is_some());
    assert_eq!(json.get("name").and_then(|v| v.as_str()), Some("CI"));
    assert!(json.get("createdAt").is_some());
    assert!(
        !serde_json::to_string(&info)
            .expect("info string")
            .contains(key.expose())
    );

    let created = CreatedUserApiKey::new(info, &key);
    let created_json = serde_json::to_value(&created).expect("serialize created");
    assert_eq!(
        created_json.get("key").and_then(|v| v.as_str()),
        Some(key.expose())
    );
    assert_eq!(
        created_json.get("name").and_then(|v| v.as_str()),
        Some("CI")
    );
    assert!(created_json.get("createdAt").is_some());
}

#[tokio::test]
async fn replace_key_leaves_one_live_key_with_that_name() {
    let repo = FakeUserApiKeysRepo::default();
    let service = UserApiKeyServiceImpl::new(repo.clone());
    let other = service
        .create_key(&user(USER_A), "other")
        .await
        .expect("create should succeed");
    let first = service
        .replace_key(&user(USER_A), "Agent signup")
        .await
        .expect("replace should succeed");
    let second = service
        .replace_key(&user(USER_A), "Agent signup")
        .await
        .expect("replace should succeed");

    let live = service
        .list_keys(&user(USER_A))
        .await
        .expect("list should succeed");
    assert_eq!(live.len(), 2);
    assert!(live.iter().any(|key| key.id == other.id));
    assert!(live.iter().any(|key| key.id == second.id));
    assert!(!live.iter().any(|key| key.id == first.id));
}