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.

28.7 KB
Raw Blame
mod create;

use axum::Extension;
use axum::Router;
use axum::body::Body;
use axum::http::{Request, StatusCode, header};
use entity_access::domain::models::TeamRole;
use entity_registry::NonUserOwners;
use http_body_util::BodyExt;
use macro_authorization::{
    BotActingUserClaims, BotAuthentication, BotScope, InternalIdentityClaims,
    MacroAuthorizationError, MacroAuthorizationService, MacroAuthorizationState,
    MacroUserAuthentication,
};
use macro_user_id::user_id::MacroUserIdStr;
use model::chat::ChatBasic;
use model::response::StringIDResponse;
use model::user::UserContext;
use model_owner::Owner;
use rootcause::Report;
use std::sync::{Arc, Mutex};
use tower::util::ServiceExt;
use uuid::Uuid;

use crate::domain::models::{
    ChatErr, ChatResponse, CreateChatArgs, GetChatResponse, PatchChatArgs, Result,
};
use crate::domain::ports::ChatService;
use crate::inbound::http::router::{
    ChatRouterState, chat_create_router, chat_id_router, chat_view_router,
};
use ai_toolset::tool_object::UserToolResponse;
use entity_access::domain::models::{
    AccessError, AccessLevel, BotAccessScope, BotId, EditAccessLevel, EntityAccessReceipt,
    EntityPermission, EntityType, OwnerAccessLevel, UserTeamInfo, ViewAccessLevel,
};
use entity_access::domain::ports::EntityAccessService;
use macro_user_id::lowercased::Lowercase;
use macro_user_id::user_id::MacroUserId;

#[derive(Clone, Default)]
struct MockService {
    created_owners: Arc<Mutex<Vec<Owner>>>,
}

impl MockService {
    fn created_owners(&self) -> Vec<Owner> {
        self.created_owners
            .lock()
            .expect("created owners lock poisoned")
            .clone()
    }
}

impl ChatService for MockService {
    async fn create(&self, owner: Owner, _args: CreateChatArgs) -> Result<String> {
        self.created_owners
            .lock()
            .expect("created owners lock poisoned")
            .push(owner);
        Ok("test-chat-id".to_string())
    }

    #[allow(deprecated)]
    async fn get_chat(
        &self,
        entity_access_receipt: EntityAccessReceipt<ViewAccessLevel>,
    ) -> Result<GetChatResponse> {
        let chat_id = entity_access_receipt.entity().entity_id.clone();
        Ok(GetChatResponse {
            chat: ChatResponse {
                id: chat_id,
                user_id: Owner::from_principal_str("macro|[email protected]").unwrap(),
                project_id: None,
                name: "Mock Chat".to_string(),
                messages: Vec::new(),
                model: None,
                created_at: None,
                updated_at: None,
            },
            user_access_level: AccessLevel::Owner,
        })
    }

    async fn get_metadata(
        &self,
        _entity_access_receipt: EntityAccessReceipt<ViewAccessLevel>,
    ) -> Result<model::chat::Chat> {
        Err(ChatErr::NotFound)
    }

    async fn copy_chat(
        &self,
        _entity_access_receipt: EntityAccessReceipt<ViewAccessLevel>,
    ) -> Result<String> {
        Ok("copied-chat-id".to_string())
    }

    async fn delete(
        &self,
        _entity_access_receipt: EntityAccessReceipt<OwnerAccessLevel>,
    ) -> Result<()> {
        Ok(())
    }

    async fn permanently_delete(
        &self,
        _entity_access_receipt: EntityAccessReceipt<OwnerAccessLevel>,
    ) -> Result<()> {
        Ok(())
    }

    async fn patch(
        &self,
        _entity_access_receipt: EntityAccessReceipt<OwnerAccessLevel>,
        _args: PatchChatArgs,
    ) -> Result<()> {
        Ok(())
    }

    async fn revert_delete(
        &self,
        _entity_access_receipt: EntityAccessReceipt<OwnerAccessLevel>,
    ) -> Result<()> {
        Ok(())
    }

    async fn get_permissions(
        &self,
        _entity_access_receipt: EntityAccessReceipt<EditAccessLevel>,
    ) -> Result<models_permissions::share_permission::SharePermissionV2> {
        Err(ChatErr::Unknown(anyhow::anyhow!("not implemented")))
    }

    async fn update_tool_call(
        &self,
        _receipt: EntityAccessReceipt<OwnerAccessLevel>,
        _message_id: &str,
        _tool_call_id: &str,
        _new_args: serde_json::Value,
    ) -> Result<()> {
        Ok(())
    }

    async fn update_tool_response(
        &self,
        _receipt: EntityAccessReceipt<OwnerAccessLevel>,
        _message_id: &str,
        _tool_call_id: &str,
        _response: UserToolResponse<serde_json::Value>,
    ) -> Result<()> {
        Ok(())
    }

    async fn call_tool(
        &self,
        _receipt: EntityAccessReceipt<OwnerAccessLevel>,
        _message_id: &str,
        _tool_call_id: &str,
        _args: Option<serde_json::Value>,
    ) -> Result<serde_json::Value> {
        Ok(serde_json::json!({
            "argsWasProvided": _args.is_some(),
            "args": _args,
        }))
    }

    async fn reject_tool_call(
        &self,
        _receipt: EntityAccessReceipt<OwnerAccessLevel>,
        _message_id: &str,
        _tool_call_id: &str,
    ) -> Result<()> {
        Ok(())
    }
}

struct ErrorService;

impl ChatService for ErrorService {
    async fn create(&self, _owner: Owner, _args: CreateChatArgs) -> Result<String> {
        Err(ChatErr::Unknown(anyhow::anyhow!("db error")))
    }

    async fn get_chat(
        &self,
        _entity_access_receipt: EntityAccessReceipt<ViewAccessLevel>,
    ) -> Result<GetChatResponse> {
        Err(ChatErr::Unknown(anyhow::anyhow!("db error")))
    }

    async fn get_metadata(
        &self,
        _entity_access_receipt: EntityAccessReceipt<ViewAccessLevel>,
    ) -> Result<model::chat::Chat> {
        Err(ChatErr::Unknown(anyhow::anyhow!("db error")))
    }

    async fn copy_chat(
        &self,
        _entity_access_receipt: EntityAccessReceipt<ViewAccessLevel>,
    ) -> Result<String> {
        Err(ChatErr::Unknown(anyhow::anyhow!("db error")))
    }

    async fn delete(
        &self,
        _entity_access_receipt: EntityAccessReceipt<OwnerAccessLevel>,
    ) -> Result<()> {
        Err(ChatErr::Unknown(anyhow::anyhow!("db error")))
    }

    async fn permanently_delete(
        &self,
        _entity_access_receipt: EntityAccessReceipt<OwnerAccessLevel>,
    ) -> Result<()> {
        Err(ChatErr::Unknown(anyhow::anyhow!("db error")))
    }

    async fn patch(
        &self,
        _entity_access_receipt: EntityAccessReceipt<OwnerAccessLevel>,
        _args: PatchChatArgs,
    ) -> Result<()> {
        Err(ChatErr::Unknown(anyhow::anyhow!("db error")))
    }

    async fn revert_delete(
        &self,
        _entity_access_receipt: EntityAccessReceipt<OwnerAccessLevel>,
    ) -> Result<()> {
        Err(ChatErr::Unknown(anyhow::anyhow!("db error")))
    }

    async fn get_permissions(
        &self,
        _entity_access_receipt: EntityAccessReceipt<EditAccessLevel>,
    ) -> Result<models_permissions::share_permission::SharePermissionV2> {
        Err(ChatErr::Unknown(anyhow::anyhow!("db error")))
    }

    async fn update_tool_call(
        &self,
        _receipt: EntityAccessReceipt<OwnerAccessLevel>,
        _message_id: &str,
        _tool_call_id: &str,
        _new_args: serde_json::Value,
    ) -> Result<()> {
        Err(ChatErr::Unknown(anyhow::anyhow!("db error")))
    }

    async fn update_tool_response(
        &self,
        _receipt: EntityAccessReceipt<OwnerAccessLevel>,
        _message_id: &str,
        _tool_call_id: &str,
        _response: UserToolResponse<serde_json::Value>,
    ) -> Result<()> {
        Err(ChatErr::Unknown(anyhow::anyhow!("db error")))
    }

    async fn call_tool(
        &self,
        _receipt: EntityAccessReceipt<OwnerAccessLevel>,
        _message_id: &str,
        _tool_call_id: &str,
        _args: Option<serde_json::Value>,
    ) -> Result<serde_json::Value> {
        Err(ChatErr::Unknown(anyhow::anyhow!("db error")))
    }

    async fn reject_tool_call(
        &self,
        _receipt: EntityAccessReceipt<OwnerAccessLevel>,
        _message_id: &str,
        _tool_call_id: &str,
    ) -> Result<()> {
        Err(ChatErr::Unknown(anyhow::anyhow!("db error")))
    }
}

struct NotFoundService;

impl ChatService for NotFoundService {
    async fn create(&self, _owner: Owner, _args: CreateChatArgs) -> Result<String> {
        Err(ChatErr::Unknown(anyhow::anyhow!("db error")))
    }

    async fn get_chat(
        &self,
        _entity_access_receipt: EntityAccessReceipt<ViewAccessLevel>,
    ) -> Result<GetChatResponse> {
        Err(ChatErr::NotFound)
    }

    async fn get_metadata(
        &self,
        _entity_access_receipt: EntityAccessReceipt<ViewAccessLevel>,
    ) -> Result<model::chat::Chat> {
        Err(ChatErr::NotFound)
    }

    async fn copy_chat(
        &self,
        _entity_access_receipt: EntityAccessReceipt<ViewAccessLevel>,
    ) -> Result<String> {
        Err(ChatErr::NotFound)
    }

    async fn delete(
        &self,
        _entity_access_receipt: EntityAccessReceipt<OwnerAccessLevel>,
    ) -> Result<()> {
        Err(ChatErr::Unknown(anyhow::anyhow!("db error")))
    }

    async fn permanently_delete(
        &self,
        _entity_access_receipt: EntityAccessReceipt<OwnerAccessLevel>,
    ) -> Result<()> {
        Err(ChatErr::Unknown(anyhow::anyhow!("db error")))
    }

    async fn patch(
        &self,
        _entity_access_receipt: EntityAccessReceipt<OwnerAccessLevel>,
        _args: PatchChatArgs,
    ) -> Result<()> {
        Err(ChatErr::Unknown(anyhow::anyhow!("db error")))
    }

    async fn revert_delete(
        &self,
        _entity_access_receipt: EntityAccessReceipt<OwnerAccessLevel>,
    ) -> Result<()> {
        Err(ChatErr::Unknown(anyhow::anyhow!("db error")))
    }

    async fn get_permissions(
        &self,
        _entity_access_receipt: EntityAccessReceipt<EditAccessLevel>,
    ) -> Result<models_permissions::share_permission::SharePermissionV2> {
        Err(ChatErr::Unknown(anyhow::anyhow!("db error")))
    }

    async fn update_tool_call(
        &self,
        _receipt: EntityAccessReceipt<OwnerAccessLevel>,
        _message_id: &str,
        _tool_call_id: &str,
        _new_args: serde_json::Value,
    ) -> Result<()> {
        Err(ChatErr::NotFound)
    }

    async fn update_tool_response(
        &self,
        _receipt: EntityAccessReceipt<OwnerAccessLevel>,
        _message_id: &str,
        _tool_call_id: &str,
        _response: UserToolResponse<serde_json::Value>,
    ) -> Result<()> {
        Err(ChatErr::NotFound)
    }

    async fn call_tool(
        &self,
        _receipt: EntityAccessReceipt<OwnerAccessLevel>,
        _message_id: &str,
        _tool_call_id: &str,
        _args: Option<serde_json::Value>,
    ) -> Result<serde_json::Value> {
        Err(ChatErr::NotFound)
    }

    async fn reject_tool_call(
        &self,
        _receipt: EntityAccessReceipt<OwnerAccessLevel>,
        _message_id: &str,
        _tool_call_id: &str,
    ) -> Result<()> {
        Err(ChatErr::NotFound)
    }
}

#[derive(Clone)]
struct MockAccessService;

impl EntityAccessService for MockAccessService {
    async fn generate_entity_access_receipt<
        T: entity_access::domain::models::RequiredPermission,
    >(
        &self,
        _user_id: &MacroUserId<Lowercase<'_>>,
        _user_org_id: Option<i64>,
        _entity_id: &str,
        _entity_type: EntityType,
    ) -> std::result::Result<entity_access::domain::models::EntityAccessReceipt<T>, AccessError>
    {
        unreachable!("not used by ChatAccessLevelExtractor")
    }

    async fn generate_bot_entity_access_receipt<
        T: entity_access::domain::models::RequiredPermission,
    >(
        &self,
        _bot_id: BotId,
        _scope: BotAccessScope,
        _entity_id: &str,
        _entity_type: EntityType,
    ) -> std::result::Result<entity_access::domain::models::EntityAccessReceipt<T>, AccessError>
    {
        unreachable!("not used by ChatAccessLevelExtractor")
    }

    async fn get_access_level(
        &self,
        _user_id: Option<&MacroUserId<Lowercase<'_>>>,
        _entity_id: &str,
        _entity_type: EntityType,
    ) -> std::result::Result<Option<AccessLevel>, AccessError> {
        Ok(Some(AccessLevel::Owner))
    }

    async fn check_access(
        &self,
        _user_id: Option<&MacroUserId<Lowercase<'_>>>,
        _entity_id: &str,
        _entity_type: EntityType,
        _required_level: AccessLevel,
    ) -> std::result::Result<AccessLevel, AccessError> {
        Ok(AccessLevel::Owner)
    }

    async fn check_public_access(
        &self,
        _entity_id: &str,
        _entity_type: EntityType,
        _required_level: AccessLevel,
    ) -> std::result::Result<AccessLevel, AccessError> {
        Ok(AccessLevel::Owner)
    }

    async fn get_entity_permission(
        &self,
        _user_id: Option<&MacroUserId<Lowercase<'_>>>,
        _entity_id: &str,
        _entity_type: EntityType,
        _user_org_id: Option<i64>,
    ) -> std::result::Result<EntityPermission, AccessError> {
        Ok(EntityPermission::AccessLevel {
            access_level: AccessLevel::Owner,
        })
    }

    async fn get_crm_entity_permission_with_team(
        &self,
        _user_id: Option<&MacroUserId<Lowercase<'_>>>,
        _entity_id: &str,
        _entity_type: EntityType,
    ) -> std::result::Result<(EntityPermission, uuid::Uuid, TeamRole), AccessError> {
        unimplemented!("chat test mock does not support CRM entity access")
    }

    async fn get_users_by_entity(
        &self,
        _entity_id: &str,
        _entity_type: EntityType,
    ) -> std::result::Result<Vec<MacroUserIdStr<'static>>, AccessError> {
        Ok(vec![])
    }

    async fn get_call_channel(
        &self,
        _call_id: &sqlx::types::Uuid,
    ) -> std::result::Result<Option<entity_access::domain::models::CallChannelInfo>, AccessError>
    {
        unimplemented!()
    }

    async fn get_call_channel_by_channel_id(
        &self,
        _channel_id: &sqlx::types::Uuid,
    ) -> std::result::Result<Option<entity_access::domain::models::CallChannelInfo>, AccessError>
    {
        unimplemented!()
    }

    async fn get_user_team(
        &self,
        _user_id: &MacroUserId<Lowercase<'_>>,
    ) -> std::result::Result<Option<UserTeamInfo>, AccessError> {
        unimplemented!()
    }
}

const BOT_TOKEN: &str = "bot-valid";
const TEAM_ID: Uuid = Uuid::from_u128(0x7EA3);

#[derive(Clone)]
struct FakeAuthorizationService;

impl MacroAuthorizationService for FakeAuthorizationService {
    async fn authorize(
        &self,
        jwt: &str,
    ) -> std::result::Result<UserContext, Report<MacroAuthorizationError>> {
        if jwt != "valid" {
            return Err(Report::new(MacroAuthorizationError::InvalidCredentials));
        }

        Ok(UserContext {
            user_id: "macro|[email protected]".to_string(),
            fusion_user_id: "1234".to_string(),
            permissions: None,
            organization_id: None,
        })
    }

    async fn authorize_identity(
        &self,
        jwt: &str,
    ) -> std::result::Result<
        macro_authorization::ValidatedCredential,
        Report<MacroAuthorizationError>,
    > {
        self.authorize(jwt)
            .await
            .map(macro_authorization::ValidatedCredential::session)
    }

    async fn authorize_internal(
        &self,
        _provided_key: &str,
        _claims: InternalIdentityClaims,
    ) -> std::result::Result<Option<UserContext>, Report<MacroAuthorizationError>> {
        Err(Report::new(MacroAuthorizationError::InvalidCredentials))
    }

    async fn authorize_bot(
        &self,
        bot_token: &str,
        bot_scope: BotScope,
        acting_user: Option<BotActingUserClaims>,
    ) -> std::result::Result<BotAuthentication, Report<MacroAuthorizationError>> {
        if bot_token != BOT_TOKEN {
            return Err(Report::new(MacroAuthorizationError::InvalidCredentials));
        }

        Ok(BotAuthentication {
            bot_id: BotId::TEST_A,
            token_id: Uuid::nil(),
            bot_scope,
            team_id: Some(TEAM_ID),
            acting_user: acting_user
                .and_then(|claims| claims.user_id)
                .map(|user_id| MacroUserAuthentication {
                    origin: macro_authorization::CredentialOrigin::Bot,
                    agent_id: None,
                    agent_via: None,
                    macro_user_id: MacroUserIdStr::try_from(user_id.clone())
                        .expect("test user id should be valid"),
                    user_context: UserContext {
                        user_id,
                        fusion_user_id: "1234".to_string(),
                        permissions: None,
                        organization_id: None,
                    },
                }),
        })
    }
}

fn authorization_state() -> MacroAuthorizationState<FakeAuthorizationService> {
    MacroAuthorizationState::new(Arc::new(FakeAuthorizationService))
}

/// Fake roles-and-permissions service granting no permissions (free tier).
#[derive(Clone)]
struct FakeUserPermissionsService;

impl roles_and_permissions::domain::port::UserRolesAndPermissionsService
    for FakeUserPermissionsService
{
    async fn get_user_roles(
        &self,
        _user_id: &macro_user_id::user_id::MacroUserIdStr<'_>,
    ) -> std::result::Result<
        std::collections::HashSet<roles_and_permissions::domain::model::RoleId>,
        roles_and_permissions::domain::model::UserRolesAndPermissionsError,
    > {
        Ok(std::collections::HashSet::new())
    }

    async fn get_user_permissions(
        &self,
        _user_id: &macro_user_id::user_id::MacroUserIdStr<'_>,
    ) -> std::result::Result<
        std::collections::HashSet<roles_and_permissions::domain::model::PermissionId>,
        roles_and_permissions::domain::model::UserRolesAndPermissionsError,
    > {
        Ok(std::collections::HashSet::new())
    }

    async fn update_user_roles_and_permissions_for_subscription(
        &self,
        _email: macro_user_id::email::Email<macro_user_id::lowercased::Lowercase<'_>>,
        _subscription_status: roles_and_permissions::domain::model::SubscriptionStatus,
        _product_tier: roles_and_permissions::domain::model::ProductTier,
    ) -> std::result::Result<(), roles_and_permissions::domain::model::UserRolesAndPermissionsError>
    {
        unimplemented!("not used by chat handlers")
    }

    async fn dangerous_upsert_roles_for_user(
        &self,
        _user_id: &macro_user_id::user_id::MacroUserIdStr<'_>,
        _role_ids: non_empty::NonEmpty<&[roles_and_permissions::domain::model::RoleId]>,
    ) -> std::result::Result<(), roles_and_permissions::domain::model::UserRolesAndPermissionsError>
    {
        unimplemented!("not used by chat handlers")
    }

    async fn dangerous_remove_roles_from_user(
        &self,
        _user_id: &macro_user_id::user_id::MacroUserIdStr<'_>,
        _role_ids: &non_empty::NonEmpty<&[roles_and_permissions::domain::model::RoleId]>,
    ) -> std::result::Result<(), roles_and_permissions::domain::model::UserRolesAndPermissionsError>
    {
        unimplemented!("not used by chat handlers")
    }
}

fn permissions_service() -> Arc<FakeUserPermissionsService> {
    Arc::new(FakeUserPermissionsService)
}

/// Attaches the test user's bearer token to every request, mirroring the
/// credentials a real client would send.
async fn attach_bearer(mut req: Request<Body>) -> Request<Body> {
    req.headers_mut().insert(
        header::AUTHORIZATION,
        "Bearer valid".parse().expect("header should be valid"),
    );
    req
}

fn chat_basic_extension() -> Extension<ChatBasic> {
    Extension(ChatBasic {
        id: "some-chat-id".to_string(),
        name: "Mock Chat".to_string(),
        user_id: Owner::from_principal_str("macro|[email protected]").unwrap(),
        project_id: None,
        deleted_at: None,
    })
}

fn mock_id_router() -> Router {
    let state = ChatRouterState::new(
        MockService::default(),
        MockAccessService,
        authorization_state(),
        permissions_service(),
        NonUserOwners::Disabled,
    );
    chat_view_router(state.clone())
        .merge(chat_id_router(state))
        .layer(chat_basic_extension())
        .layer(axum::middleware::map_request(attach_bearer))
}

fn error_id_router() -> Router {
    let state = ChatRouterState::new(
        ErrorService,
        MockAccessService,
        authorization_state(),
        permissions_service(),
        NonUserOwners::Disabled,
    );
    chat_view_router(state.clone())
        .merge(chat_id_router(state))
        .layer(chat_basic_extension())
        .layer(axum::middleware::map_request(attach_bearer))
}

fn not_found_id_router() -> Router {
    let state = ChatRouterState::new(
        NotFoundService,
        MockAccessService,
        authorization_state(),
        permissions_service(),
        NonUserOwners::Disabled,
    );
    chat_view_router(state.clone())
        .merge(chat_id_router(state))
        .layer(chat_basic_extension())
        .layer(axum::middleware::map_request(attach_bearer))
}

// -- get_chat tests --

#[tokio::test]
async fn get_chat_returns_chat() {
    let req = Request::builder()
        .uri("/some-chat-id")
        .body(Body::empty())
        .unwrap();

    let res = mock_id_router().oneshot(req).await.unwrap();
    assert_eq!(res.status(), StatusCode::OK);

    let body = res.into_body().collect().await.unwrap().to_bytes();
    let response: GetChatResponse = serde_json::from_slice(&body).unwrap();
    assert_eq!(response.chat.id, "some-chat-id");
    assert_eq!(response.chat.name, "Mock Chat");
    assert_eq!(response.user_access_level, AccessLevel::Owner);
}

#[tokio::test]
async fn get_chat_not_found_returns_404() {
    let req = Request::builder()
        .uri("/nonexistent")
        .body(Body::empty())
        .unwrap();

    let res = not_found_id_router().oneshot(req).await.unwrap();
    assert_eq!(res.status(), StatusCode::NOT_FOUND);
}

#[tokio::test]
async fn get_chat_repo_error_returns_500() {
    let req = Request::builder()
        .uri("/some-chat-id")
        .body(Body::empty())
        .unwrap();

    let res = error_id_router().oneshot(req).await.unwrap();
    assert_eq!(res.status(), StatusCode::INTERNAL_SERVER_ERROR);
}

// -- delete_chat tests --

#[tokio::test]
async fn delete_chat_returns_ok() {
    let req = Request::builder()
        .method("DELETE")
        .uri("/some-chat-id")
        .body(Body::empty())
        .unwrap();

    let res = mock_id_router().oneshot(req).await.unwrap();
    assert_eq!(res.status(), StatusCode::OK);
}

#[tokio::test]
async fn delete_chat_repo_error_returns_500() {
    let req = Request::builder()
        .method("DELETE")
        .uri("/some-chat-id")
        .body(Body::empty())
        .unwrap();

    let res = error_id_router().oneshot(req).await.unwrap();
    assert_eq!(res.status(), StatusCode::INTERNAL_SERVER_ERROR);
}

// -- permanently_delete_chat tests --

#[tokio::test]
async fn permanently_delete_chat_returns_ok() {
    let req = Request::builder()
        .method("DELETE")
        .uri("/some-chat-id/permanent")
        .body(Body::empty())
        .unwrap();

    let res = mock_id_router().oneshot(req).await.unwrap();
    assert_eq!(res.status(), StatusCode::OK);
}

#[tokio::test]
async fn permanently_delete_chat_repo_error_returns_500() {
    let req = Request::builder()
        .method("DELETE")
        .uri("/some-chat-id/permanent")
        .body(Body::empty())
        .unwrap();

    let res = error_id_router().oneshot(req).await.unwrap();
    assert_eq!(res.status(), StatusCode::INTERNAL_SERVER_ERROR);
}

// -- patch_chat tests --

#[tokio::test]
async fn patch_chat_returns_ok() {
    let req = Request::builder()
        .method("PATCH")
        .uri("/some-chat-id")
        .header("content-type", "application/json")
        .body(Body::from(r#"{"name": "Renamed"}"#))
        .unwrap();

    let res = mock_id_router().oneshot(req).await.unwrap();
    assert_eq!(res.status(), StatusCode::OK);
}

#[tokio::test]
async fn patch_chat_repo_error_returns_500() {
    let req = Request::builder()
        .method("PATCH")
        .uri("/some-chat-id")
        .header("content-type", "application/json")
        .body(Body::from(r#"{"name": "Renamed"}"#))
        .unwrap();

    let res = error_id_router().oneshot(req).await.unwrap();
    assert_eq!(res.status(), StatusCode::INTERNAL_SERVER_ERROR);
}

// -- copy_chat tests --

#[tokio::test]
async fn copy_chat_returns_id() {
    let req = Request::builder()
        .method("POST")
        .uri("/some-chat-id/copy")
        .body(Body::empty())
        .unwrap();

    let res = mock_id_router().oneshot(req).await.unwrap();
    assert_eq!(res.status(), StatusCode::OK);

    let body = res.into_body().collect().await.unwrap().to_bytes();
    let response: StringIDResponse = serde_json::from_slice(&body).unwrap();
    assert_eq!(response.id, "copied-chat-id");
}

#[tokio::test]
async fn copy_chat_repo_error_returns_500() {
    let req = Request::builder()
        .method("POST")
        .uri("/some-chat-id/copy")
        .body(Body::empty())
        .unwrap();

    let res = error_id_router().oneshot(req).await.unwrap();
    assert_eq!(res.status(), StatusCode::INTERNAL_SERVER_ERROR);
}

// -- revert_delete tests --

#[tokio::test]
async fn revert_delete_returns_ok() {
    let req = Request::builder()
        .method("PUT")
        .uri("/some-chat-id/revert_delete")
        .body(Body::empty())
        .unwrap();

    let res = mock_id_router().oneshot(req).await.unwrap();
    assert_eq!(res.status(), StatusCode::OK);
}

#[tokio::test]
async fn revert_delete_repo_error_returns_500() {
    let req = Request::builder()
        .method("PUT")
        .uri("/some-chat-id/revert_delete")
        .body(Body::empty())
        .unwrap();

    let res = error_id_router().oneshot(req).await.unwrap();
    assert_eq!(res.status(), StatusCode::INTERNAL_SERVER_ERROR);
}

// -- get_chat_permissions tests --

#[tokio::test]
async fn get_permissions_repo_error_returns_500() {
    let req = Request::builder()
        .uri("/some-chat-id/permissions")
        .body(Body::empty())
        .unwrap();

    let res = error_id_router().oneshot(req).await.unwrap();
    assert_eq!(res.status(), StatusCode::INTERNAL_SERVER_ERROR);
}

// -- tool handler tests --

#[tokio::test]
async fn update_tool_call_returns_ok() {
    let req = Request::builder()
        .method("POST")
        .uri("/some-chat-id/tool/update")
        .header("content-type", "application/json")
        .body(Body::from(
            r#"{"messageId":"message-1","toolCallId":"tool-1","args":{"x":1}}"#,
        ))
        .unwrap();

    let res = mock_id_router().oneshot(req).await.unwrap();
    assert_eq!(res.status(), StatusCode::OK);
}

#[tokio::test]
async fn update_tool_response_returns_ok() {
    let req = Request::builder()
        .method("POST")
        .uri("/some-chat-id/tool/response/update")
        .header("content-type", "application/json")
        .body(Body::from(
            r#"{"messageId":"message-1","toolCallId":"tool-1","response":{"UserAction":{"draftId":"draft-1"}}}"#,
        ))
        .unwrap();

    let res = mock_id_router().oneshot(req).await.unwrap();
    assert_eq!(res.status(), StatusCode::OK);
}

#[tokio::test]
async fn call_tool_returns_result() {
    let req = Request::builder()
        .method("POST")
        .uri("/some-chat-id/tool/call")
        .header("content-type", "application/json")
        .body(Body::from(
            r#"{"messageId":"message-1","toolCallId":"tool-1","args":{"x":1}}"#,
        ))
        .unwrap();

    let res = mock_id_router().oneshot(req).await.unwrap();
    assert_eq!(res.status(), StatusCode::OK);

    let body = res.into_body().collect().await.unwrap().to_bytes();
    let response: serde_json::Value = serde_json::from_slice(&body).unwrap();
    assert_eq!(
        response,
        serde_json::json!({
            "result": {
                "argsWasProvided": true,
                "args": { "x": 1 },
            }
        })
    );
}

#[tokio::test]
async fn call_tool_forwards_missing_args() {
    let req = Request::builder()
        .method("POST")
        .uri("/some-chat-id/tool/call")
        .header("content-type", "application/json")
        .body(Body::from(
            r#"{"messageId":"message-1","toolCallId":"tool-1"}"#,
        ))
        .unwrap();

    let res = mock_id_router().oneshot(req).await.unwrap();
    assert_eq!(res.status(), StatusCode::OK);

    let body = res.into_body().collect().await.unwrap().to_bytes();
    let response: serde_json::Value = serde_json::from_slice(&body).unwrap();
    assert_eq!(
        response,
        serde_json::json!({
            "result": {
                "argsWasProvided": false,
                "args": null,
            }
        })
    );
}

#[tokio::test]
async fn reject_tool_call_returns_ok() {
    let req = Request::builder()
        .method("POST")
        .uri("/some-chat-id/tool/reject")
        .header("content-type", "application/json")
        .body(Body::from(
            r#"{"messageId":"message-1","toolCallId":"tool-1"}"#,
        ))
        .unwrap();

    let res = mock_id_router().oneshot(req).await.unwrap();
    assert_eq!(res.status(), StatusCode::OK);
}