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.

87.4 KB
Raw Blame
use std::sync::{Arc, Mutex};

use bot_id::{BotId, NonSystemBotId};
use entity_access::domain::models::{
    EditAccessLevel, Entity, EntityAccessAuth, EntityAccessReceipt, EntityPermission, EntityType,
    OwnerAccessLevel, ViewAccessLevel,
};
use entity_access_management::domain::models::EntityAccessManagementError;
use entity_access_management::domain::ports::EntityAccessManagementService;
use entity_mutation::{EntityMutationEffect, RestoreEntity};
use macro_event_broker::{EventBrokerError, MacroEvent, MacroEventBroker};
use macro_user_id::user_id::MacroUserIdStr;
use model::document::{ContentType, DocumentMetadata, FileType};
use model::folder::{
    FileSystemNodeWithIds, FolderItem, S3Destination, UploadFolderRequest,
    UploadFolderWithIdsResponse,
};
use model::item::Item;
use model::project::request::{CreateProjectRequest, PatchProjectRequestV2};
use model::project::{
    BasicProject, Project, ProjectPreviewData, ProjectPreviewV2, ProjectWithUploadRequest,
};
use model_owner::{CreationPrincipal, Owner};
use models_bulk_upload::{
    BulkUploadRequest, BulkUploadRequestDocuments, ProjectDocumentStatus, UploadDocumentStatus,
    UploadExtractFolderRequest, UploadFolderStatus,
};
use models_permissions::share_permission::access_level::AccessLevel;
use models_permissions::share_permission::{LinkShare, UpdateSharePermissionRequestV2};
use s3_key::BulkUploadStagingKey;
use uuid::Uuid;

use super::*;
use crate::domain::events::{ProjectCreatedMetadata, ProjectMacroEvent};
use crate::domain::models::{MarkedUploadedTree, PurgedProjectTree};
use crate::domain::ports::MockProjectRepo;

/// A project lifecycle event recorded by [`TestEventBroker`].
#[derive(Clone, Debug)]
pub(super) struct PublishedEvent {
    topic: &'static str,
    key: String,
    pub(super) payload: serde_json::Value,
}

#[derive(Clone, Default)]
pub(super) struct TestEventBroker {
    published: Arc<Mutex<Vec<PublishedEvent>>>,
    fail: bool,
}

impl TestEventBroker {
    fn failing() -> Self {
        Self {
            fail: true,
            ..Self::default()
        }
    }

    pub(super) fn published(&self) -> Arc<Mutex<Vec<PublishedEvent>>> {
        Arc::clone(&self.published)
    }
}

impl MacroEventBroker for TestEventBroker {
    fn send_event<E: MacroEvent + ?Sized>(
        &self,
        event: &E,
    ) -> Result<tokio::task::JoinHandle<Result<(), EventBrokerError>>, EventBrokerError> {
        if self.fail {
            return Err(EventBrokerError::Publish("test failure".to_string()));
        }

        self.published.lock().unwrap().push(PublishedEvent {
            topic: event.topic(),
            key: event.key().to_string(),
            payload: serde_json::to_value(event.event())?,
        });
        Ok(tokio::spawn(async { Ok(()) }))
    }
}

#[derive(Clone, Copy)]
pub(super) struct NullPort;

impl ProjectUploadUrlPort for NullPort {
    async fn put_upload_zip_staging_presigned_url(
        &self,
        _key: BulkUploadStagingKey,
        _sha: String,
    ) -> anyhow::Result<String> {
        unreachable!()
    }

    async fn put_document_storage_presigned_url(
        &self,
        _key: String,
        _sha: String,
        _content_type: ContentType,
    ) -> anyhow::Result<String> {
        unreachable!()
    }

    async fn put_docx_upload_presigned_url(
        &self,
        _key: String,
        _sha: String,
        _content_type: ContentType,
    ) -> anyhow::Result<String> {
        unreachable!()
    }

    fn document_storage_bucket(&self) -> &str {
        "unused"
    }

    fn docx_upload_bucket(&self) -> &str {
        "unused"
    }
}

impl ShaCounterPort for NullPort {
    async fn decrement_counts(&self, _sha_counts: &[(String, i64)]) -> anyhow::Result<()> {
        unreachable!()
    }
}

impl EntityAccessManagementService for NullPort {
    async fn add_entity_to_project(
        &self,
        _entity_id: &Uuid,
        _entity_type: EntityType,
        _project_id: &Uuid,
    ) -> Result<(), EntityAccessManagementError> {
        unreachable!()
    }

    async fn remove_entity_from_project(
        &self,
        _entity_id: &Uuid,
        _entity_type: EntityType,
        _old_project_id: &Uuid,
    ) -> Result<(), EntityAccessManagementError> {
        unreachable!()
    }

    async fn move_project(
        &self,
        _project_id: &Uuid,
        _old_project_id: Option<&Uuid>,
        _new_project_id: Option<&Uuid>,
    ) -> Result<(), EntityAccessManagementError> {
        unreachable!()
    }
}

impl ProjectSearchIndexer for NullPort {
    async fn remove_documents(&self, _document_ids: Vec<String>) -> anyhow::Result<()> {
        unreachable!()
    }

    async fn enqueue_document_deletes(
        &self,
        _documents: Vec<(String, String)>,
    ) -> anyhow::Result<()> {
        unreachable!()
    }
}

#[derive(Clone, Debug, PartialEq, Eq)]
enum EamCall {
    Add(Uuid, Uuid),
    Move(Uuid, Option<Uuid>, Option<Uuid>),
}

#[derive(Clone, Default)]
struct RecordingEam {
    calls: Arc<Mutex<Vec<EamCall>>>,
}

impl EntityAccessManagementService for RecordingEam {
    async fn add_entity_to_project(
        &self,
        entity_id: &Uuid,
        _entity_type: EntityType,
        project_id: &Uuid,
    ) -> Result<(), EntityAccessManagementError> {
        self.calls
            .lock()
            .unwrap()
            .push(EamCall::Add(*entity_id, *project_id));
        Ok(())
    }

    async fn remove_entity_from_project(
        &self,
        _entity_id: &Uuid,
        _entity_type: EntityType,
        _old_project_id: &Uuid,
    ) -> Result<(), EntityAccessManagementError> {
        unreachable!()
    }

    async fn move_project(
        &self,
        project_id: &Uuid,
        old_project_id: Option<&Uuid>,
        new_project_id: Option<&Uuid>,
    ) -> Result<(), EntityAccessManagementError> {
        self.calls.lock().unwrap().push(EamCall::Move(
            *project_id,
            old_project_id.copied(),
            new_project_id.copied(),
        ));
        Ok(())
    }
}

#[derive(Clone, Copy, Default)]
struct RecordingIndexer {
    _unused: (),
}

impl ProjectSearchIndexer for RecordingIndexer {
    async fn remove_documents(&self, _document_ids: Vec<String>) -> anyhow::Result<()> {
        unreachable!()
    }

    async fn enqueue_document_deletes(
        &self,
        _documents: Vec<(String, String)>,
    ) -> anyhow::Result<()> {
        unreachable!()
    }
}

fn mutation_service(
    repo: MockProjectRepo,
    eam: RecordingEam,
    indexer: RecordingIndexer,
) -> ProjectServiceImpl<
    MockProjectRepo,
    NullPort,
    RecordingBulkUpload,
    NullPort,
    RecordingEam,
    RecordingIndexer,
    TestEventBroker,
> {
    mutation_service_with_event_broker(repo, eam, indexer, TestEventBroker::default())
}

fn mutation_service_with_event_broker(
    repo: MockProjectRepo,
    eam: RecordingEam,
    indexer: RecordingIndexer,
    event_broker: TestEventBroker,
) -> ProjectServiceImpl<
    MockProjectRepo,
    NullPort,
    RecordingBulkUpload,
    NullPort,
    RecordingEam,
    RecordingIndexer,
    TestEventBroker,
> {
    ProjectServiceImpl::new(
        repo,
        NullPort,
        RecordingBulkUpload::default(),
        NullPort,
        eam,
        indexer,
        None,
        event_broker,
    )
}

#[derive(Clone, Default)]
pub(super) struct RecordingBulkUpload {
    calls: Arc<Mutex<Vec<String>>>,
}

impl BulkUploadRequestPort for RecordingBulkUpload {
    async fn create_bulk_upload_request(
        &self,
        _request_id: Uuid,
        _user_id: &str,
        _name: Option<&str>,
        _parent_id: Option<&str>,
    ) -> anyhow::Result<BulkUploadRequest> {
        unreachable!()
    }

    async fn get_bulk_upload_document_statuses(
        &self,
        upload_request_id: &str,
    ) -> anyhow::Result<BulkUploadRequestDocuments> {
        self.calls
            .lock()
            .unwrap()
            .push(upload_request_id.to_string());
        match upload_request_id {
            "failed" => anyhow::bail!("sensitive dynamo failure"),
            "mismatch" => Ok(BulkUploadRequestDocuments {
                root_project_id: "another-project".to_string(),
                documents: vec![document_status()],
            }),
            _ => Ok(BulkUploadRequestDocuments {
                root_project_id: upload_request_id.to_string(),
                documents: vec![document_status()],
            }),
        }
    }
}

fn service<D: BulkUploadRequestPort>(
    repo: MockProjectRepo,
    bulk_upload_service: D,
) -> ProjectServiceImpl<MockProjectRepo, NullPort, D, NullPort, NullPort, NullPort, TestEventBroker>
{
    service_with_event_broker(repo, bulk_upload_service, TestEventBroker::default())
}

pub(super) fn service_with_event_broker<D: BulkUploadRequestPort>(
    repo: MockProjectRepo,
    bulk_upload_service: D,
    event_broker: TestEventBroker,
) -> ProjectServiceImpl<MockProjectRepo, NullPort, D, NullPort, NullPort, NullPort, TestEventBroker>
{
    ProjectServiceImpl::new(
        repo,
        NullPort,
        bulk_upload_service,
        NullPort,
        NullPort,
        NullPort,
        None,
        event_broker,
    )
}

fn user_id(value: &str) -> MacroUserIdStr<'static> {
    MacroUserIdStr::try_from(value.to_string()).unwrap()
}

fn owner(value: &str) -> Owner {
    Owner::from_principal_str(value).unwrap()
}

#[test]
fn event_actor_user_id_only_maps_authenticated_users() {
    let user_id = user_id("macro|[email protected]");

    assert_eq!(
        event_actor_user_id(&EntityAccessAuth::Authenticated(user_id.clone())),
        Some(user_id)
    );
    assert_eq!(
        event_actor_user_id(&EntityAccessAuth::Unauthenticated),
        None
    );
    assert_eq!(event_actor_user_id(&EntityAccessAuth::Internal), None);
}

#[tokio::test]
async fn publish_project_event_records_the_serialized_envelope() {
    let event_broker = TestEventBroker::default();
    let published = event_broker.published();
    let service = service_with_event_broker(
        MockProjectRepo::new(),
        RecordingBulkUpload::default(),
        event_broker,
    );
    let event = ProjectMacroEvent::created(
        "project-id",
        ProjectCreatedMetadata {
            project_id: "project-id".to_string(),
            owner: owner("macro|[email protected]"),
            name: "Project".to_string(),
            parent_project_id: None,
            created_at: None,
        },
    );

    service.publish_project_event(&event);

    let published = published.lock().unwrap();
    assert_eq!(published.len(), 1);
    assert_eq!(published[0].topic, "macro.projects");
    assert_eq!(published[0].key, "project-id");
    assert_eq!(published[0].payload["schema_version"], 1);
    assert_eq!(published[0].payload["event_type"], "project.created");
    assert_eq!(published[0].payload["metadata"]["name"], "Project");
}

#[test]
fn publish_project_event_errors_are_non_fatal() {
    let service = service_with_event_broker(
        MockProjectRepo::new(),
        RecordingBulkUpload::default(),
        TestEventBroker::failing(),
    );
    let event = ProjectMacroEvent::created(
        "project-id",
        ProjectCreatedMetadata {
            project_id: "project-id".to_string(),
            owner: owner("macro|[email protected]"),
            name: "Project".to_string(),
            parent_project_id: None,
            created_at: None,
        },
    );

    service.publish_project_event(&event);
}

fn project(id: &str, owner_id: &str, parent_id: Option<&str>) -> Project {
    Project {
        id: id.to_string(),
        name: id.to_string(),
        user_id: owner(owner_id),
        parent_id: parent_id.map(str::to_string),
        created_at: None,
        updated_at: None,
        deleted_at: None,
    }
}

fn receipt(
    auth: EntityAccessAuth,
    access_level: AccessLevel,
) -> EntityAccessReceipt<ViewAccessLevel> {
    EntityAccessReceipt::try_new(
        auth,
        Entity {
            entity_id: "root".to_string(),
            entity_type: EntityType::Project,
        },
        EntityPermission::AccessLevel { access_level },
    )
    .unwrap()
}

pub(super) fn basic_project(id: Uuid, parent_id: Option<Uuid>, deleted: bool) -> BasicProject {
    BasicProject {
        id: id.to_string(),
        user_id: owner("macro|[email protected]"),
        parent_id: parent_id.map(|id| id.to_string()),
        name: "Project".to_string(),
        deleted_at: deleted.then(chrono::Utc::now),
    }
}

fn mutation_receipt<T>(project_id: Uuid, access_level: AccessLevel) -> EntityAccessReceipt<T>
where
    T: entity_access::domain::models::RequiredPermission,
{
    mutation_receipt_with_auth(
        project_id,
        access_level,
        EntityAccessAuth::Authenticated(user_id("macro|[email protected]")),
    )
}

fn mutation_receipt_with_auth<T>(
    project_id: Uuid,
    access_level: AccessLevel,
    auth: EntityAccessAuth,
) -> EntityAccessReceipt<T>
where
    T: entity_access::domain::models::RequiredPermission,
{
    EntityAccessReceipt::try_new(
        auth,
        Entity {
            entity_id: project_id.to_string(),
            entity_type: EntityType::Project,
        },
        EntityPermission::AccessLevel { access_level },
    )
    .unwrap()
}

pub(super) fn assert_project_event(event: &PublishedEvent, key: Uuid, event_type: &str) {
    assert_eq!(event.topic, "macro.projects");
    assert_eq!(event.key, key.to_string());
    assert!(Uuid::parse_str(event.payload["event_id"].as_str().unwrap()).is_ok());
    assert_eq!(event.payload["schema_version"], 1);
    assert_eq!(event.payload["event_type"], event_type);
}

fn patch_request(
    parent_id: Option<String>,
    share_permission: Option<UpdateSharePermissionRequestV2>,
) -> PatchProjectRequestV2 {
    PatchProjectRequestV2 {
        name: None,
        project_parent_id: parent_id,
        share_permission,
    }
}

fn share_update() -> UpdateSharePermissionRequestV2 {
    UpdateSharePermissionRequestV2 {
        link_share: Some(Some(LinkShare::Public)),
        link_share_access_level: Some(Some(AccessLevel::View)),
        team_share_access_level: None,
        channel_share_permissions: None,
    }
}

fn document_status() -> ProjectDocumentStatus {
    ProjectDocumentStatus {
        document_id: "document".to_string(),
        status: UploadDocumentStatus::Pending,
    }
}

#[tokio::test]
async fn content_attributes_owner_access_to_owned_items() {
    let mut repo = MockProjectRepo::new();
    repo.expect_get_project_children().return_once(|_| {
        Box::pin(async {
            Ok(vec![
                Item::Project(project("owned", "macro|[email protected]", Some("root"))),
                Item::Project(project("shared", "macro|[email protected]", Some("root"))),
            ])
        })
    });
    let service = service(repo, RecordingBulkUpload::default());

    let content = service
        .get_project_content(receipt(
            EntityAccessAuth::Authenticated(user_id("macro|[email protected]")),
            AccessLevel::Edit,
        ))
        .await
        .unwrap();

    assert_eq!(content[0].user_access_level, AccessLevel::Owner);
    assert_eq!(content[1].user_access_level, AccessLevel::Edit);
}

#[tokio::test]
async fn content_does_not_attribute_bot_or_team_owned_items_to_the_user() {
    let mut repo = MockProjectRepo::new();
    repo.expect_get_project_children().return_once(|_| {
        Box::pin(async {
            Ok(vec![
                Item::Project(project(
                    "bot-owned",
                    "bot|00000000-0000-0000-0000-00000000a1a1",
                    Some("root"),
                )),
                Item::Project(project(
                    "team-owned",
                    "01234567-89ab-cdef-0123-456789abcdef",
                    Some("root"),
                )),
            ])
        })
    });
    let service = service(repo, RecordingBulkUpload::default());

    let content = service
        .get_project_content(receipt(
            EntityAccessAuth::Authenticated(user_id("macro|[email protected]")),
            AccessLevel::Edit,
        ))
        .await
        .unwrap();

    assert_eq!(content[0].user_access_level, AccessLevel::Edit);
    assert_eq!(content[1].user_access_level, AccessLevel::Edit);
}

#[tokio::test]
async fn content_attributes_owner_access_to_every_item_for_internal_receipts() {
    let mut repo = MockProjectRepo::new();
    repo.expect_get_project_children().return_once(|_| {
        Box::pin(async {
            Ok(vec![Item::Project(project(
                "shared",
                "macro|[email protected]",
                Some("root"),
            ))])
        })
    });
    let service = service(repo, RecordingBulkUpload::default());

    let content = service
        .get_project_content(receipt(EntityAccessAuth::Internal, AccessLevel::View))
        .await
        .unwrap();

    assert_eq!(content[0].user_access_level, AccessLevel::Owner);
}

#[tokio::test]
async fn pending_projects_isolate_status_failures_and_root_mismatches() {
    let mut repo = MockProjectRepo::new();
    repo.expect_get_pending_root_projects().return_once(|_| {
        Box::pin(async {
            Ok(vec![
                ProjectWithUploadRequest {
                    project: project("failed", "macro|[email protected]", None),
                    upload_request_id: Some("failed".to_string()),
                },
                ProjectWithUploadRequest {
                    project: project("mismatch", "macro|[email protected]", None),
                    upload_request_id: Some("mismatch".to_string()),
                },
                ProjectWithUploadRequest {
                    project: project("nested", "macro|[email protected]", Some("root")),
                    upload_request_id: Some("nested".to_string()),
                },
                ProjectWithUploadRequest {
                    project: project("without-request", "macro|[email protected]", None),
                    upload_request_id: None,
                },
            ])
        })
    });
    let bulk_upload = RecordingBulkUpload::default();
    let calls = bulk_upload.calls.clone();
    let service = service(repo, bulk_upload);

    let pending = service
        .list_pending_projects(user_id("macro|[email protected]"))
        .await
        .unwrap();

    assert_eq!(pending.len(), 2);
    assert!(
        pending
            .iter()
            .all(|project| project.document_statuses.is_empty())
    );
    assert!(pending.iter().any(|project| project.project.id == "failed"));
    assert!(
        pending
            .iter()
            .any(|project| project.project.id == "without-request")
    );
    let mut calls = calls.lock().unwrap().clone();
    calls.sort();
    assert_eq!(calls, vec!["failed", "mismatch"]);
}

#[tokio::test]
async fn preview_deduplicates_ids_before_calling_repository() {
    let mut repo = MockProjectRepo::new();
    repo.expect_batch_get_project_preview()
        .withf(|ids| {
            ids.len() == 2 && ids.iter().any(|id| id == "one") && ids.iter().any(|id| id == "two")
        })
        .return_once(|_| {
            Box::pin(async {
                Ok(vec![ProjectPreviewV2::Found(ProjectPreviewData {
                    id: "one".to_string(),
                    name: "One".to_string(),
                    owner: owner("macro|[email protected]"),
                    path: Vec::new(),
                    updated_at: None,
                })])
            })
        });
    let service = service(repo, RecordingBulkUpload::default());

    let previews = service
        .get_batch_preview(
            Some(user_id("macro|[email protected]")),
            vec!["one".to_string(), "two".to_string(), "one".to_string()],
        )
        .await
        .unwrap();

    assert_eq!(previews.len(), 1);
    assert!(matches!(&previews[0], ProjectPreview::Access(data) if data.id == "one"));
}

#[tokio::test]
async fn create_uses_grapheme_limit_and_orchestrates_parent_side_effects() {
    let project_id = Uuid::new_v4();
    let parent_id = Uuid::new_v4();
    let accepted_name = "👨‍👩‍👧‍👦".repeat(100);
    let expected_name = accepted_name.clone();
    let mut repo = MockProjectRepo::new();
    repo.expect_get_team_default_link_share()
        .returning(|_| Box::pin(async { Ok(None) }));
    repo.expect_create_project()
        .withf(move |args| {
            args.owner == owner("macro|[email protected]")
                && args.name == expected_name
                && args.parent_id.as_deref() == Some(parent_id.to_string().as_str())
                && args.share_permission.link_share.is_none()
                && args.share_permission.link_share_access_level.is_none()
        })
        .return_once(move |_| {
            Box::pin(async move {
                Ok(project(
                    &project_id.to_string(),
                    "macro|[email protected]",
                    Some(&parent_id.to_string()),
                ))
            })
        });
    repo.expect_update_project_modified()
        .withf(move |id| id == parent_id.to_string())
        .return_once(|_| Box::pin(async { Ok(()) }));
    let eam = RecordingEam::default();
    let eam_calls = eam.calls.clone();
    let service = mutation_service(repo, eam, RecordingIndexer::default());

    service
        .create_project(
            &CreationPrincipal::User(user_id("macro|[email protected]")),
            CreateProjectRequest {
                name: accepted_name,
                project_parent_id: Some(parent_id),
            },
        )
        .await
        .unwrap();
    let error = service
        .create_project(
            &CreationPrincipal::User(user_id("macro|[email protected]")),
            CreateProjectRequest {
                name: "👨‍👩‍👧‍👦".repeat(101),
                project_parent_id: None,
            },
        )
        .await
        .unwrap_err();

    assert!(matches!(error, ProjectError::NameTooLong { max: 100 }));
    assert_eq!(
        *eam_calls.lock().unwrap(),
        vec![EamCall::Add(project_id, parent_id)]
    );
}

#[tokio::test]
async fn create_project_publishes_repository_metadata_after_success() {
    let project_id = Uuid::new_v4();
    let parent_id = Uuid::new_v4();
    let created_at = chrono::Utc::now();
    let expected_created_at = serde_json::to_value(created_at).unwrap();
    let mut repo = MockProjectRepo::new();
    repo.expect_get_team_default_link_share()
        .returning(|_| Box::pin(async { Ok(None) }));
    repo.expect_create_project().return_once(move |_| {
        Box::pin(async move {
            let mut created = project(
                &project_id.to_string(),
                "macro|[email protected]",
                Some(&parent_id.to_string()),
            );
            created.name = "Repository name".to_string();
            created.created_at = Some(created_at);
            Ok(created)
        })
    });
    repo.expect_update_project_modified()
        .return_once(|_| Box::pin(async { Ok(()) }));
    let event_broker = TestEventBroker::default();
    let published = event_broker.published();
    let service = mutation_service_with_event_broker(
        repo,
        RecordingEam::default(),
        RecordingIndexer::default(),
        event_broker,
    );

    let result = service
        .create_project(
            &CreationPrincipal::User(user_id("macro|[email protected]")),
            CreateProjectRequest {
                name: "Requested name".to_string(),
                project_parent_id: Some(parent_id),
            },
        )
        .await
        .unwrap();

    assert_eq!(result.name, "Repository name");
    let published = published.lock().unwrap();
    assert_eq!(published.len(), 1);
    assert_eq!(published[0].topic, "macro.projects");
    assert_eq!(published[0].key, project_id.to_string());
    let metadata = &published[0].payload["metadata"];
    assert_eq!(metadata["project_id"], project_id.to_string());
    assert_eq!(metadata["owner"], "macro|[email protected]");
    assert_eq!(metadata["name"], "Repository name");
    assert_eq!(metadata["parent_project_id"], parent_id.to_string());
    assert_eq!(metadata["created_at"], expected_created_at);
}

#[tokio::test]
async fn a_project_dated_by_contents_starts_never_edited_and_leaves_its_parent_alone() {
    let parent_id = Uuid::new_v4();
    let mut repo = MockProjectRepo::new();
    repo.expect_get_team_default_link_share()
        .returning(|_| Box::pin(async { Ok(None) }));
    repo.expect_create_project()
        .withf(|args| args.updated_at == Some(chrono::DateTime::UNIX_EPOCH))
        .return_once(move |_| {
            Box::pin(async move {
                Ok(project(
                    &Uuid::new_v4().to_string(),
                    "macro|[email protected]",
                    Some(&parent_id.to_string()),
                ))
            })
        });
    repo.expect_update_project_modified().times(0);
    let service = mutation_service_with_event_broker(
        repo,
        RecordingEam::default(),
        RecordingIndexer::default(),
        TestEventBroker::default(),
    );

    service
        .create_project_dated_by_contents(
            &CreationPrincipal::User(user_id("macro|[email protected]")),
            CreateProjectRequest {
                name: "Imported".to_string(),
                project_parent_id: Some(parent_id),
            },
        )
        .await
        .unwrap();
}

#[tokio::test]
async fn create_project_failures_publish_no_event() {
    let mut repo = MockProjectRepo::new();
    repo.expect_get_team_default_link_share()
        .returning(|_| Box::pin(async { Ok(None) }));
    repo.expect_create_project()
        .return_once(|_| Box::pin(async { Err(anyhow::anyhow!("database unavailable")) }));
    let event_broker = TestEventBroker::default();
    let published = event_broker.published();
    let service = mutation_service_with_event_broker(
        repo,
        RecordingEam::default(),
        RecordingIndexer::default(),
        event_broker,
    );

    let validation_error = service
        .create_project(
            &CreationPrincipal::User(user_id("macro|[email protected]")),
            CreateProjectRequest {
                name: "x".repeat(101),
                project_parent_id: None,
            },
        )
        .await;
    let repository_error = service
        .create_project(
            &CreationPrincipal::User(user_id("macro|[email protected]")),
            CreateProjectRequest {
                name: "Project".to_string(),
                project_parent_id: None,
            },
        )
        .await;

    assert!(validation_error.is_err());
    assert!(repository_error.is_err());
    assert!(published.lock().unwrap().is_empty());
}

#[tokio::test]
async fn create_project_succeeds_when_event_publication_fails() {
    let project_id = Uuid::new_v4();
    let mut repo = MockProjectRepo::new();
    repo.expect_get_team_default_link_share()
        .returning(|_| Box::pin(async { Ok(None) }));
    repo.expect_create_project().return_once(move |_| {
        Box::pin(async move {
            Ok(project(
                &project_id.to_string(),
                "macro|[email protected]",
                None,
            ))
        })
    });
    let service = mutation_service_with_event_broker(
        repo,
        RecordingEam::default(),
        RecordingIndexer::default(),
        TestEventBroker::failing(),
    );

    let result = service
        .create_project(
            &CreationPrincipal::User(user_id("macro|[email protected]")),
            CreateProjectRequest {
                name: "Project".to_string(),
                project_parent_id: None,
            },
        )
        .await
        .unwrap();

    assert_eq!(result.id, project_id.to_string());
}

#[tokio::test]
async fn create_project_resolves_share_permission_from_team_default() {
    use models_permissions::share_permission::access_level::AccessLevel;
    use models_permissions::share_permission::{LinkShare, TeamLinkShareDefault};

    let project_id = Uuid::new_v4();
    let mut repo = MockProjectRepo::new();
    repo.expect_get_team_default_link_share()
        .withf(|owner| owner == &Owner::User(user_id("macro|[email protected]")))
        .returning(|_| Box::pin(async { Ok(Some(TeamLinkShareDefault(Some(LinkShare::Team)))) }));
    repo.expect_create_project()
        .withf(|args| {
            args.share_permission.link_share == Some(LinkShare::Team)
                && args.share_permission.link_share_access_level == Some(AccessLevel::View)
        })
        .return_once(move |_| {
            Box::pin(async move {
                Ok(project(
                    &project_id.to_string(),
                    "macro|[email protected]",
                    None,
                ))
            })
        });
    let service = mutation_service(repo, RecordingEam::default(), RecordingIndexer::default());

    service
        .create_project(
            &CreationPrincipal::User(user_id("macro|[email protected]")),
            CreateProjectRequest {
                name: "Project".to_string(),
                project_parent_id: None,
            },
        )
        .await
        .unwrap();
}

#[tokio::test]
async fn team_bot_creates_a_bot_owned_project_and_publishes_the_bot_owner() {
    let project_id = Uuid::new_v4();
    let mut repo = MockProjectRepo::new();
    repo.expect_get_team_default_link_share()
        .withf(|owner| owner == &Owner::Bot(BotId::TEST_A))
        .returning(|_| Box::pin(async { Ok(None) }));
    repo.expect_create_project()
        .withf(|args| args.owner == Owner::Bot(BotId::TEST_A) && args.name == "Bot project")
        .return_once(move |_| {
            Box::pin(async move {
                Ok(project(
                    &project_id.to_string(),
                    "bot|00000000-0000-0000-0000-00000000b07a",
                    None,
                ))
            })
        });
    let event_broker = TestEventBroker::default();
    let published = event_broker.published();
    let service = mutation_service_with_event_broker(
        repo,
        RecordingEam::default(),
        RecordingIndexer::default(),
        event_broker,
    );

    service
        .create_project(
            &CreationPrincipal::TeamBot {
                bot: NonSystemBotId::new(BotId::TEST_A).unwrap(),
                team: Uuid::from_u128(0x7ea3),
            },
            CreateProjectRequest {
                name: "Bot project".to_string(),
                project_parent_id: None,
            },
        )
        .await
        .unwrap();

    let published = published.lock().unwrap();
    assert_eq!(published.len(), 1);
    assert_eq!(published[0].payload["event_type"], "project.created");
    assert_eq!(
        published[0].payload["metadata"]["owner"],
        "bot|00000000-0000-0000-0000-00000000b07a"
    );
}

#[tokio::test]
async fn edit_project_publishes_requested_update_metadata() {
    struct Case {
        name: Option<&'static str>,
        old_parent: Option<Uuid>,
        requested_parent: Option<String>,
        sharing: bool,
    }

    let cases = [
        Case {
            name: Some("Renamed"),
            old_parent: None,
            requested_parent: None,
            sharing: false,
        },
        Case {
            name: None,
            old_parent: None,
            requested_parent: Some(Uuid::new_v4().to_string()),
            sharing: false,
        },
        Case {
            name: None,
            old_parent: Some(Uuid::new_v4()),
            requested_parent: Some(String::new()),
            sharing: false,
        },
        Case {
            name: None,
            old_parent: None,
            requested_parent: None,
            sharing: true,
        },
        Case {
            name: Some("Combined"),
            old_parent: Some(Uuid::new_v4()),
            requested_parent: Some(Uuid::new_v4().to_string()),
            sharing: true,
        },
    ];

    for case in cases {
        let project_id = Uuid::new_v4();
        let mut repo = MockProjectRepo::new();
        repo.expect_get_team_share_facts().times(0);
        if case
            .requested_parent
            .as_deref()
            .is_some_and(|parent| !parent.is_empty())
        {
            repo.expect_is_project_recursively_nested()
                .return_once(|_, _| Box::pin(async { Ok(false) }));
        }
        repo.expect_edit_project().return_once(move |_| {
            Box::pin(async move {
                Ok(project(
                    &project_id.to_string(),
                    "macro|[email protected]",
                    None,
                ))
            })
        });
        let bump_count = 1
            + usize::from(case.old_parent.is_some())
            + usize::from(
                case.requested_parent
                    .as_deref()
                    .is_some_and(|parent| !parent.is_empty()),
            );
        repo.expect_update_project_modified()
            .times(bump_count)
            .returning(|_| Box::pin(async { Ok(()) }));
        let event_broker = TestEventBroker::default();
        let published = event_broker.published();
        let service = mutation_service_with_event_broker(
            repo,
            RecordingEam::default(),
            RecordingIndexer::default(),
            event_broker,
        );
        let mut request = patch_request(
            case.requested_parent.clone(),
            case.sharing.then(share_update),
        );
        request.name = case.name.map(str::to_string);

        service
            .edit_project(
                mutation_receipt::<EditAccessLevel>(project_id, AccessLevel::Owner),
                basic_project(project_id, case.old_parent, false),
                request,
            )
            .await
            .unwrap();

        let published = published.lock().unwrap();
        assert_eq!(published.len(), 1);
        assert_eq!(published[0].key, project_id.to_string());
        assert_eq!(published[0].payload["event_type"], "project.updated");
        let metadata = &published[0].payload["metadata"];
        assert_eq!(metadata["project_id"], project_id.to_string());
        assert_eq!(metadata["owner"], "macro|[email protected]");
        assert_eq!(metadata["actor_user_id"], "macro|[email protected]");
        assert_eq!(metadata["name"], serde_json::json!(case.name));
        assert_eq!(
            metadata["previous_parent_id"],
            serde_json::json!(case.old_parent.map(|id| id.to_string()))
        );
        assert_eq!(
            metadata["parent_id"],
            serde_json::json!(case.requested_parent)
        );
        assert_eq!(metadata["share_permission_updated"], case.sharing);
    }
}

#[tokio::test]
async fn edit_requires_owner_for_moves_and_share_changes() {
    let project_id = Uuid::new_v4();
    let parent_id = Uuid::new_v4();
    let repo = MockProjectRepo::new();
    let service = mutation_service(repo, RecordingEam::default(), RecordingIndexer::default());

    let move_error = service
        .edit_project(
            mutation_receipt::<EditAccessLevel>(project_id, AccessLevel::Edit),
            basic_project(project_id, None, false),
            patch_request(Some(parent_id.to_string()), None),
        )
        .await
        .unwrap_err();
    let share_error = service
        .edit_project(
            mutation_receipt::<EditAccessLevel>(project_id, AccessLevel::Edit),
            basic_project(project_id, None, false),
            patch_request(None, Some(share_update())),
        )
        .await
        .unwrap_err();

    assert!(matches!(
        move_error,
        ProjectError::UnauthorizedWithMessage(_)
    ));
    assert!(matches!(
        share_error,
        ProjectError::UnauthorizedWithMessage(_)
    ));
}

#[tokio::test]
async fn edit_rejects_deleted_self_recursive_and_invalid_parents() {
    let project_id = Uuid::new_v4();
    let recursive_parent = Uuid::new_v4();
    let mut repo = MockProjectRepo::new();
    repo.expect_is_project_recursively_nested()
        .withf(move |id, parent| {
            id == project_id.to_string() && parent == recursive_parent.to_string()
        })
        .return_once(|_, _| Box::pin(async { Ok(true) }));
    let service = mutation_service(repo, RecordingEam::default(), RecordingIndexer::default());

    let deleted = service
        .edit_project(
            mutation_receipt::<EditAccessLevel>(project_id, AccessLevel::Owner),
            basic_project(project_id, None, true),
            patch_request(None, None),
        )
        .await
        .unwrap_err();
    let self_parent = service
        .edit_project(
            mutation_receipt::<EditAccessLevel>(project_id, AccessLevel::Owner),
            basic_project(project_id, None, false),
            patch_request(Some(project_id.to_string()), None),
        )
        .await
        .unwrap_err();
    let invalid_parent = service
        .edit_project(
            mutation_receipt::<EditAccessLevel>(project_id, AccessLevel::Owner),
            basic_project(project_id, None, false),
            patch_request(Some("not-a-uuid".to_string()), None),
        )
        .await
        .unwrap_err();
    let recursive = service
        .edit_project(
            mutation_receipt::<EditAccessLevel>(project_id, AccessLevel::Owner),
            basic_project(project_id, None, false),
            patch_request(Some(recursive_parent.to_string()), None),
        )
        .await
        .unwrap_err();

    assert!(matches!(deleted, ProjectError::CannotModifyDeleted));
    assert!(matches!(self_parent, ProjectError::BadRequest(_)));
    assert!(matches!(invalid_parent, ProjectError::BadRequest(_)));
    assert!(matches!(recursive, ProjectError::RecursiveNesting));
}

#[tokio::test]
async fn edit_project_failures_publish_no_event() {
    let project_id = Uuid::new_v4();
    let recursive_parent = Uuid::new_v4();
    let mut repo = MockProjectRepo::new();
    repo.expect_is_project_recursively_nested()
        .return_once(|_, _| Box::pin(async { Ok(true) }));
    repo.expect_edit_project()
        .return_once(|_| Box::pin(async { Err(anyhow::anyhow!("database unavailable").into()) }));
    let event_broker = TestEventBroker::default();
    let published = event_broker.published();
    let service = mutation_service_with_event_broker(
        repo,
        RecordingEam::default(),
        RecordingIndexer::default(),
        event_broker,
    );

    let mut invalid_name = patch_request(None, None);
    invalid_name.name = Some("x".repeat(101));
    let validation_error = service
        .edit_project(
            mutation_receipt::<EditAccessLevel>(project_id, AccessLevel::Edit),
            basic_project(project_id, None, false),
            invalid_name,
        )
        .await;
    let authorization_error = service
        .edit_project(
            mutation_receipt::<EditAccessLevel>(project_id, AccessLevel::Edit),
            basic_project(project_id, None, false),
            patch_request(Some(Uuid::new_v4().to_string()), None),
        )
        .await;
    let recursive_error = service
        .edit_project(
            mutation_receipt::<EditAccessLevel>(project_id, AccessLevel::Owner),
            basic_project(project_id, None, false),
            patch_request(Some(recursive_parent.to_string()), None),
        )
        .await;
    let mut rename = patch_request(None, None);
    rename.name = Some("Renamed".to_string());
    let repository_error = service
        .edit_project(
            mutation_receipt::<EditAccessLevel>(project_id, AccessLevel::Edit),
            basic_project(project_id, None, false),
            rename,
        )
        .await;

    assert!(validation_error.is_err());
    assert!(authorization_error.is_err());
    assert!(matches!(
        recursive_error,
        Err(ProjectError::RecursiveNesting)
    ));
    assert!(repository_error.is_err());
    assert!(published.lock().unwrap().is_empty());
}

#[tokio::test]
async fn edit_project_succeeds_when_event_publication_fails() {
    let project_id = Uuid::new_v4();
    let mut repo = MockProjectRepo::new();
    repo.expect_get_team_share_facts().times(0);
    repo.expect_edit_project().return_once(move |_| {
        Box::pin(async move {
            Ok(project(
                &project_id.to_string(),
                "macro|[email protected]",
                None,
            ))
        })
    });
    repo.expect_update_project_modified()
        .return_once(|_| Box::pin(async { Ok(()) }));
    let service = mutation_service_with_event_broker(
        repo,
        RecordingEam::default(),
        RecordingIndexer::default(),
        TestEventBroker::failing(),
    );
    let mut request = patch_request(None, None);
    request.name = Some("Renamed".to_string());

    let result = service
        .edit_project(
            mutation_receipt::<EditAccessLevel>(project_id, AccessLevel::Edit),
            basic_project(project_id, None, false),
            request,
        )
        .await;

    assert!(result.is_ok());
}

#[tokio::test]
async fn owner_edit_propagates_move_and_updates_all_modified_timestamps() {
    let project_id = Uuid::new_v4();
    let old_parent_id = Uuid::new_v4();
    let new_parent_id = Uuid::new_v4();
    let bumped = Arc::new(Mutex::new(Vec::new()));
    let recorded_bumps = bumped.clone();
    let mut repo = MockProjectRepo::new();
    repo.expect_is_project_recursively_nested()
        .return_once(|_, _| Box::pin(async { Ok(false) }));
    repo.expect_edit_project()
        .withf(move |args| {
            args.project_id == project_id.to_string()
                && args.update_parent
                && args.parent_id.as_deref() == Some(new_parent_id.to_string().as_str())
                && args.team_share.is_none()
        })
        .return_once(move |_| {
            Box::pin(async move {
                Ok(project(
                    &project_id.to_string(),
                    "macro|[email protected]",
                    Some(&new_parent_id.to_string()),
                ))
            })
        });
    repo.expect_update_project_modified()
        .times(3)
        .returning(move |id| {
            recorded_bumps.lock().unwrap().push(id.to_string());
            Box::pin(async { Ok(()) })
        });
    let eam = RecordingEam::default();
    let eam_calls = eam.calls.clone();
    let service = mutation_service(repo, eam, RecordingIndexer::default());

    service
        .edit_project(
            mutation_receipt::<EditAccessLevel>(project_id, AccessLevel::Owner),
            basic_project(project_id, Some(old_parent_id), false),
            patch_request(Some(new_parent_id.to_string()), Some(share_update())),
        )
        .await
        .unwrap();

    assert_eq!(
        *eam_calls.lock().unwrap(),
        vec![EamCall::Move(
            project_id,
            Some(old_parent_id),
            Some(new_parent_id)
        )]
    );
    assert_eq!(
        *bumped.lock().unwrap(),
        vec![
            project_id.to_string(),
            old_parent_id.to_string(),
            new_parent_id.to_string(),
        ]
    );
}

#[tokio::test]
async fn sharing_a_nested_project_keeps_what_it_inherits_from_its_parent() {
    let project_id = Uuid::new_v4();
    let parent_id = Uuid::new_v4();
    let facts = team_share_facts(project_id, owner_user(), Some(TEAM_ID), 0);
    let mut repo = MockProjectRepo::new();
    repo.expect_get_team_share_facts()
        .return_once(move |_| Box::pin(async move { Ok(facts) }));
    repo.expect_edit_project()
        .withf(|args| !args.update_parent && args.team_share.is_some())
        .return_once(move |_| {
            Box::pin(async move {
                Ok(project(
                    &project_id.to_string(),
                    "macro|[email protected]",
                    Some(&parent_id.to_string()),
                ))
            })
        });
    repo.expect_update_project_modified()
        .times(2)
        .returning(|_| Box::pin(async { Ok(()) }));
    let eam = RecordingEam::default();
    let calls = eam.calls.clone();
    let service = mutation_service(repo, eam, RecordingIndexer::default());

    service
        .edit_project(
            mutation_receipt::<EditAccessLevel>(project_id, AccessLevel::Owner),
            basic_project(project_id, Some(parent_id), false),
            team_share_args(Some(AccessLevel::Edit)),
        )
        .await
        .unwrap();

    assert_eq!(
        *calls.lock().unwrap(),
        Vec::new(),
        "no move, so no inherited access is dropped"
    );
}

#[tokio::test]
async fn empty_parent_clears_persistence_and_eam_parent_argument() {
    let project_id = Uuid::new_v4();
    let old_parent_id = Uuid::new_v4();
    let mut repo = MockProjectRepo::new();
    repo.expect_edit_project()
        .withf(|args| args.update_parent && args.parent_id.is_none() && args.team_share.is_none())
        .return_once(move |_| {
            Box::pin(async move {
                Ok(project(
                    &project_id.to_string(),
                    "macro|[email protected]",
                    None,
                ))
            })
        });
    repo.expect_update_project_modified()
        .times(2)
        .returning(|_| Box::pin(async { Ok(()) }));
    let eam = RecordingEam::default();
    let calls = eam.calls.clone();
    let service = mutation_service(repo, eam, RecordingIndexer::default());

    service
        .edit_project(
            mutation_receipt::<EditAccessLevel>(project_id, AccessLevel::Owner),
            basic_project(project_id, Some(old_parent_id), false),
            patch_request(Some(String::new()), None),
        )
        .await
        .unwrap();

    assert_eq!(
        *calls.lock().unwrap(),
        vec![EamCall::Move(project_id, Some(old_parent_id), None)]
    );
}

#[tokio::test]
async fn edit_name_limit_counts_unicode_graphemes() {
    let project_id = Uuid::new_v4();
    let mut repo = MockProjectRepo::new();
    repo.expect_get_team_share_facts().times(0);
    repo.expect_edit_project().return_once(move |_| {
        Box::pin(async move {
            Ok(project(
                &project_id.to_string(),
                "macro|[email protected]",
                None,
            ))
        })
    });
    repo.expect_update_project_modified()
        .return_once(|_| Box::pin(async { Ok(()) }));
    let service = mutation_service(repo, RecordingEam::default(), RecordingIndexer::default());
    let mut accepted = patch_request(None, None);
    accepted.name = Some("é".repeat(100));

    service
        .edit_project(
            mutation_receipt::<EditAccessLevel>(project_id, AccessLevel::Edit),
            basic_project(project_id, None, false),
            accepted,
        )
        .await
        .unwrap();
    let mut rejected = patch_request(None, None);
    rejected.name = Some("é".repeat(101));
    let error = service
        .edit_project(
            mutation_receipt::<EditAccessLevel>(project_id, AccessLevel::Edit),
            basic_project(project_id, None, false),
            rejected,
        )
        .await
        .unwrap_err();

    assert!(matches!(error, ProjectError::NameTooLong { max: 100 }));
}

#[tokio::test]
async fn failed_project_modified_update_is_non_fatal() {
    let project_id = Uuid::new_v4();
    let mut repo = MockProjectRepo::new();
    repo.expect_update_project_modified()
        .withf(move |id| id == project_id.to_string())
        .return_once(|_| Box::pin(async { Err(anyhow::anyhow!("database unavailable")) }));
    let service = mutation_service(repo, RecordingEam::default(), RecordingIndexer::default());

    service.bump_project_modified(&project_id.to_string()).await;
}

#[tokio::test]
async fn soft_delete_updates_parent_timestamp_and_publishes_event() {
    let project_id = Uuid::new_v4();
    let parent_id = Uuid::new_v4();
    let deleted_ids = vec![project_id.to_string(), Uuid::new_v4().to_string()];
    let expected_deleted_ids = deleted_ids.clone();
    let mut repo = MockProjectRepo::new();
    repo.expect_soft_delete_project().return_once(move |_| {
        Box::pin(async move {
            Ok(SoftDeleteResult {
                project_ids: deleted_ids,
                document_ids: vec!["document".to_string()],
                chat_ids: vec!["chat".to_string()],
            })
        })
    });
    repo.expect_update_project_modified()
        .withf(move |id| id == parent_id.to_string())
        .return_once(|_| Box::pin(async { Ok(()) }));
    let event_broker = TestEventBroker::default();
    let published = event_broker.published();
    let service = mutation_service_with_event_broker(
        repo,
        RecordingEam::default(),
        RecordingIndexer::default(),
        event_broker,
    );

    service
        .soft_delete_project(
            mutation_receipt::<OwnerAccessLevel>(project_id, AccessLevel::Owner),
            basic_project(project_id, Some(parent_id), false),
            "unused-actor".to_string(),
        )
        .await
        .unwrap();

    let published = published.lock().unwrap();
    assert_eq!(published.len(), 1);
    assert_project_event(&published[0], project_id, "project.deleted");
    let metadata = &published[0].payload["metadata"];
    assert_eq!(metadata["project_id"], project_id.to_string());
    assert_eq!(metadata["owner"], "macro|[email protected]");
    assert_eq!(metadata["actor_user_id"], "macro|[email protected]");
    assert_eq!(metadata["parent_project_id"], parent_id.to_string());
    assert_eq!(
        metadata["deleted_project_ids"],
        serde_json::json!(expected_deleted_ids)
    );
    assert_eq!(
        metadata["deleted_document_ids"],
        serde_json::json!(["document"])
    );
    assert_eq!(metadata["deleted_chat_ids"], serde_json::json!(["chat"]));
}

#[tokio::test]
async fn revert_publishes_every_restored_project_in_event() {
    let project_id = Uuid::new_v4();
    let parent_id = Uuid::new_v4();
    let restored_ids = vec![project_id.to_string(), Uuid::new_v4().to_string()];
    let expected_ids = restored_ids.clone();
    let mut repo = MockProjectRepo::new();
    repo.expect_revert_delete_project()
        .withf(move |id, parent| {
            id == project_id.to_string()
                && parent.as_deref() == Some(parent_id.to_string().as_str())
        })
        .return_once(move |_, _| {
            Box::pin(async move {
                Ok(crate::domain::models::RevertDeleteResult {
                    project_ids: restored_ids,
                    document_ids: Vec::new(),
                    chat_ids: Vec::new(),
                })
            })
        });
    let event_broker = TestEventBroker::default();
    let published = event_broker.published();
    let service = mutation_service_with_event_broker(
        repo,
        RecordingEam::default(),
        RecordingIndexer::default(),
        event_broker,
    );

    service
        .revert_delete_project(
            mutation_receipt_with_auth::<OwnerAccessLevel>(
                project_id,
                AccessLevel::Owner,
                EntityAccessAuth::Internal,
            ),
            basic_project(project_id, Some(parent_id), true),
        )
        .await
        .unwrap();

    let published = published.lock().unwrap();
    assert_eq!(published.len(), 1);
    assert_project_event(&published[0], project_id, "project.restored");
    let metadata = &published[0].payload["metadata"];
    assert_eq!(metadata["project_id"], project_id.to_string());
    assert_eq!(metadata["owner"], "macro|[email protected]");
    assert!(metadata["actor_user_id"].is_null());
    assert_eq!(metadata["parent_project_id"], parent_id.to_string());
    assert_eq!(
        metadata["restored_project_ids"],
        serde_json::json!(expected_ids)
    );
}

#[tokio::test]
async fn restore_entity_returns_document_and_chat_effects() {
    let project_id = Uuid::new_v4();
    let child_project_id = Uuid::new_v4();
    let parent_id = Uuid::new_v4();
    let document_id = "restored-document".to_string();
    let chat_id = "restored-chat".to_string();
    let restored_project_ids = vec![project_id.to_string(), child_project_id.to_string()];

    let mut repo = MockProjectRepo::new();
    let project = basic_project(project_id, Some(parent_id), true);
    repo.expect_get_basic_project()
        .withf(move |id| id == project_id.to_string())
        .return_once(move |_| Box::pin(async move { Ok(Some(project)) }));
    let returned_project_ids = restored_project_ids.clone();
    let returned_document_id = document_id.clone();
    let returned_chat_id = chat_id.clone();
    repo.expect_revert_delete_project()
        .return_once(move |_, _| {
            Box::pin(async move {
                Ok(crate::domain::models::RevertDeleteResult {
                    project_ids: returned_project_ids,
                    document_ids: vec![returned_document_id],
                    chat_ids: vec![returned_chat_id],
                })
            })
        });
    let service = mutation_service(repo, RecordingEam::default(), RecordingIndexer::default());
    let entity = EntityType::Project.with_entity_string(project_id.to_string());

    let effects = service
        .restore_entity(
            entity.clone(),
            mutation_receipt_with_auth::<OwnerAccessLevel>(
                project_id,
                AccessLevel::Owner,
                EntityAccessAuth::Internal,
            ),
        )
        .await
        .unwrap();

    assert_eq!(
        effects,
        vec![
            EntityMutationEffect::updated(entity),
            EntityMutationEffect::updated(
                EntityType::Project.with_entity_string(child_project_id.to_string()),
            ),
            EntityMutationEffect::updated(EntityType::Document.with_entity_string(document_id),),
            EntityMutationEffect::updated(EntityType::Chat.with_entity_string(chat_id)),
            EntityMutationEffect::updated(
                EntityType::Project.with_entity_string(parent_id.to_string()),
            ),
        ]
    );
}

#[tokio::test]
async fn deletion_repository_failures_publish_no_events() {
    let project_id = Uuid::new_v4();
    let mut repo = MockProjectRepo::new();
    repo.expect_soft_delete_project()
        .return_once(|_| Box::pin(async { Err(anyhow::anyhow!("delete failed")) }));
    repo.expect_revert_delete_project()
        .return_once(|_, _| Box::pin(async { Err(anyhow::anyhow!("restore failed")) }));
    let event_broker = TestEventBroker::default();
    let published = event_broker.published();
    let service = mutation_service_with_event_broker(
        repo,
        RecordingEam::default(),
        RecordingIndexer::default(),
        event_broker,
    );

    let delete_result = service
        .soft_delete_project(
            mutation_receipt::<OwnerAccessLevel>(project_id, AccessLevel::Owner),
            basic_project(project_id, None, false),
            "unused".to_string(),
        )
        .await;
    let restore_result = service
        .revert_delete_project(
            mutation_receipt::<OwnerAccessLevel>(project_id, AccessLevel::Owner),
            basic_project(project_id, None, true),
        )
        .await;

    assert!(delete_result.is_err());
    assert!(restore_result.is_err());
    assert!(published.lock().unwrap().is_empty());
}

#[tokio::test]
async fn soft_delete_succeeds_when_event_publication_fails() {
    let project_id = Uuid::new_v4();
    let mut repo = MockProjectRepo::new();
    repo.expect_soft_delete_project().return_once(move |_| {
        Box::pin(async move {
            Ok(SoftDeleteResult {
                project_ids: vec![project_id.to_string()],
                document_ids: Vec::new(),
                chat_ids: Vec::new(),
            })
        })
    });
    let service = mutation_service_with_event_broker(
        repo,
        RecordingEam::default(),
        RecordingIndexer::default(),
        TestEventBroker::failing(),
    );

    let result = service
        .soft_delete_project(
            mutation_receipt::<OwnerAccessLevel>(project_id, AccessLevel::Owner),
            basic_project(project_id, None, false),
            "unused".to_string(),
        )
        .await;

    assert!(result.is_ok());
}

#[tokio::test]
async fn missing_full_project_maps_to_not_found() {
    let mut repo = MockProjectRepo::new();
    repo.expect_get_project_by_id()
        .return_once(|_| Box::pin(async { Ok(None) }));
    let service = service(repo, RecordingBulkUpload::default());

    let error = service
        .get_project(receipt(
            EntityAccessAuth::Authenticated(user_id("macro|[email protected]")),
            AccessLevel::View,
        ))
        .await
        .unwrap_err();

    assert!(matches!(error, ProjectError::NotFound(id) if id == "root"));
}

#[derive(Clone)]
struct OrderedSha {
    events: Arc<Mutex<Vec<&'static str>>>,
}

impl ShaCounterPort for OrderedSha {
    async fn decrement_counts(&self, _sha_counts: &[(String, i64)]) -> anyhow::Result<()> {
        self.events.lock().unwrap().push("sha");
        Ok(())
    }
}

#[derive(Clone, Copy)]
struct FailingSha;

impl ShaCounterPort for FailingSha {
    async fn decrement_counts(&self, _sha_counts: &[(String, i64)]) -> anyhow::Result<()> {
        anyhow::bail!("sha counter unavailable")
    }
}

#[derive(Clone)]
struct OrderedIndexer {
    events: Arc<Mutex<Vec<&'static str>>>,
    fail: bool,
}

impl OrderedIndexer {
    fn record(&self, event: &'static str) -> anyhow::Result<()> {
        self.events.lock().unwrap().push(event);
        if self.fail {
            anyhow::bail!("index unavailable");
        }
        Ok(())
    }
}

impl ProjectSearchIndexer for OrderedIndexer {
    async fn remove_documents(&self, _document_ids: Vec<String>) -> anyhow::Result<()> {
        self.record("documents")
    }

    async fn enqueue_document_deletes(
        &self,
        _documents: Vec<(String, String)>,
    ) -> anyhow::Result<()> {
        self.record("document_deletes")
    }
}

#[derive(Clone)]
struct RecordingUploadUrls {
    calls: Arc<Mutex<Vec<String>>>,
    fail_document: bool,
}

impl ProjectUploadUrlPort for RecordingUploadUrls {
    async fn put_upload_zip_staging_presigned_url(
        &self,
        key: BulkUploadStagingKey,
        _sha: String,
    ) -> anyhow::Result<String> {
        self.calls.lock().unwrap().push(key.to_key());
        Ok("https://upload.example".to_string())
    }

    async fn put_document_storage_presigned_url(
        &self,
        key: String,
        _sha: String,
        _content_type: ContentType,
    ) -> anyhow::Result<String> {
        self.calls.lock().unwrap().push(key);
        if self.fail_document {
            anyhow::bail!("sensitive S3 failure");
        }
        Ok("https://document.example".to_string())
    }

    async fn put_docx_upload_presigned_url(
        &self,
        _key: String,
        _sha: String,
        _content_type: ContentType,
    ) -> anyhow::Result<String> {
        unreachable!()
    }

    fn document_storage_bucket(&self) -> &str {
        "documents-bucket"
    }

    fn docx_upload_bucket(&self) -> &str {
        "docx-bucket"
    }
}

#[derive(Clone)]
struct RecordingExtract {
    request_ids: Arc<Mutex<Vec<Uuid>>>,
}

impl BulkUploadRequestPort for RecordingExtract {
    async fn create_bulk_upload_request(
        &self,
        request_id: Uuid,
        user_id: &str,
        name: Option<&str>,
        parent_id: Option<&str>,
    ) -> anyhow::Result<BulkUploadRequest> {
        self.request_ids.lock().unwrap().push(request_id);
        Ok(BulkUploadRequest {
            request_id: request_id.to_string(),
            user_id: user_id.to_string(),
            key: format!("extract/{request_id}"),
            status: UploadFolderStatus::Pending,
            name: name.map(str::to_string),
            created_at: String::new(),
            updated_at: String::new(),
            completed_at: None,
            error_message: None,
            root_project_id: None,
            parent_id: parent_id.map(str::to_string),
        })
    }

    async fn get_bulk_upload_document_statuses(
        &self,
        _upload_request_id: &str,
    ) -> anyhow::Result<BulkUploadRequestDocuments> {
        unreachable!()
    }
}

fn upload_document(id: &str, file_type: FileType) -> DocumentMetadata {
    DocumentMetadata::new_document(
        id,
        7,
        model_owner::Owner::User(user_id("macro|[email protected]")),
        id,
        Some(file_type),
        "0123456789abcdef",
        None,
        None,
        None,
        Some("project"),
        Some("Project"),
        None,
        None,
        None,
    )
}

#[tokio::test]
async fn permanent_delete_runs_external_work_after_committed_purge() {
    let events = Arc::new(Mutex::new(Vec::new()));
    let repo_events = events.clone();
    let mut repo = MockProjectRepo::new();
    repo.expect_purge_deleted_project_tree()
        .return_once(move |_| {
            repo_events.lock().unwrap().push("repo");
            Box::pin(async {
                Ok(PurgedProjectTree {
                    project_ids: vec!["project".to_string()],
                    chat_ids: vec!["chat".to_string()],
                    documents: vec![("document".to_string(), "owner".to_string())],
                    bom_shas: vec![("sha".to_string(), 2)],
                })
            })
        });
    let event_broker = TestEventBroker::default();
    let published = event_broker.published();
    let service = ProjectServiceImpl::new(
        repo,
        NullPort,
        RecordingBulkUpload::default(),
        OrderedSha {
            events: events.clone(),
        },
        NullPort,
        OrderedIndexer {
            events: events.clone(),
            fail: true,
        },
        None,
        event_broker,
    );

    let project_id = Uuid::new_v4();
    let parent_id = Uuid::new_v4();
    service
        .permanently_delete_project(
            mutation_receipt::<OwnerAccessLevel>(project_id, AccessLevel::Owner),
            basic_project(project_id, Some(parent_id), true),
        )
        .await
        .unwrap();

    assert_eq!(
        *events.lock().unwrap(),
        vec!["repo", "sha", "documents", "document_deletes"]
    );
    let published = published.lock().unwrap();
    assert_eq!(published.len(), 1);
    assert_project_event(&published[0], project_id, "project.permanently_deleted");
    let metadata = &published[0].payload["metadata"];
    assert_eq!(metadata["project_id"], project_id.to_string());
    assert_eq!(metadata["owner"], "macro|[email protected]");
    assert_eq!(metadata["actor_user_id"], "macro|[email protected]");
    assert_eq!(metadata["parent_project_id"], parent_id.to_string());
    assert_eq!(
        metadata["purged_project_ids"],
        serde_json::json!(["project"])
    );
    assert_eq!(
        metadata["purged_document_ids"],
        serde_json::json!(["document"])
    );
    assert_eq!(metadata["purged_chat_ids"], serde_json::json!(["chat"]));
}

#[tokio::test]
async fn permanent_delete_has_no_external_side_effects_when_purge_fails() {
    let mut repo = MockProjectRepo::new();
    repo.expect_purge_deleted_project_tree()
        .return_once(|_| Box::pin(async { Err(anyhow::anyhow!("commit failed")) }));
    let event_broker = TestEventBroker::default();
    let published = event_broker.published();
    let service = service_with_event_broker(repo, RecordingBulkUpload::default(), event_broker);

    let project_id = Uuid::new_v4();
    let result = service
        .permanently_delete_project(
            mutation_receipt::<OwnerAccessLevel>(project_id, AccessLevel::Owner),
            basic_project(project_id, None, true),
        )
        .await;

    assert!(result.is_err());
    assert!(published.lock().unwrap().is_empty());
}

#[tokio::test]
async fn permanent_delete_sha_failure_publishes_no_event() {
    let mut repo = MockProjectRepo::new();
    repo.expect_purge_deleted_project_tree().return_once(|_| {
        Box::pin(async {
            Ok(PurgedProjectTree {
                project_ids: vec!["project".to_string()],
                chat_ids: Vec::new(),
                documents: Vec::new(),
                bom_shas: vec![("sha".to_string(), 1)],
            })
        })
    });
    let event_broker = TestEventBroker::default();
    let published = event_broker.published();
    let service = ProjectServiceImpl::new(
        repo,
        NullPort,
        RecordingBulkUpload::default(),
        FailingSha,
        NullPort,
        RecordingIndexer::default(),
        None,
        event_broker,
    );
    let project_id = Uuid::new_v4();

    let result = service
        .permanently_delete_project(
            mutation_receipt::<OwnerAccessLevel>(project_id, AccessLevel::Owner),
            basic_project(project_id, None, true),
        )
        .await;

    assert!(result.is_err());
    assert!(published.lock().unwrap().is_empty());
}

#[tokio::test]
async fn destination_maps_preserve_internal_external_and_docx_behavior() {
    let urls = RecordingUploadUrls {
        calls: Arc::new(Mutex::new(Vec::new())),
        fail_document: false,
    };
    let pdf = upload_document("pdf", FileType::Pdf);
    let docx = upload_document("docx", FileType::Docx);

    let internal = build_destination_map(&urls, &[pdf.clone(), docx.clone()], true)
        .await
        .unwrap();
    assert!(matches!(
        internal.get("pdf"),
        Some(S3Destination::Internal(info)) if info.bucket == "documents-bucket"
    ));
    assert!(matches!(
        internal.get("docx"),
        Some(S3Destination::Internal(info)) if info.bucket == "docx-bucket"
    ));

    let external = build_destination_map(&urls, &[pdf, docx], false)
        .await
        .unwrap();
    assert!(matches!(
        external.get("pdf"),
        Some(S3Destination::External(_))
    ));
    assert!(!external.contains_key("docx"));
}

#[tokio::test]
async fn mark_projects_uploaded_publishes_root_metadata_and_returns_subtree_ids() {
    let root_project_id = "root-project";
    let project_ids = vec![
        root_project_id.to_string(),
        "child-project".to_string(),
        "grandchild-project".to_string(),
    ];
    let expected_project_ids = project_ids.clone();
    let mut repo = MockProjectRepo::new();
    repo.expect_mark_projects_uploaded()
        .withf(move |id| id == root_project_id)
        .return_once(move |_| {
            Box::pin(async move {
                Ok(MarkedUploadedTree {
                    id: root_project_id.to_string(),
                    name: "Uploaded tree".to_string(),
                    user_id: user_id("macro|[email protected]"),
                    parent_id: Some("parent-project".to_string()),
                    project_ids,
                    upload_pending_transitioned: true,
                })
            })
        });
    let event_broker = TestEventBroker::default();
    let published = event_broker.published();
    let service = service_with_event_broker(repo, RecordingBulkUpload::default(), event_broker);

    let result = service
        .mark_projects_uploaded(root_project_id)
        .await
        .unwrap();

    assert_eq!(result, expected_project_ids);
    let published = published.lock().unwrap();
    assert_eq!(published.len(), 1);
    assert_eq!(published[0].topic, "macro.projects");
    assert_eq!(published[0].key, root_project_id);
    assert_eq!(published[0].payload["schema_version"], 1);
    assert_eq!(published[0].payload["event_type"], "project.uploaded");
    assert_eq!(
        published[0].payload["metadata"],
        serde_json::json!({
            "root_project_id": root_project_id,
            "owner": "macro|[email protected]",
            "name": "Uploaded tree",
            "parent_project_id": "parent-project",
            "project_ids": expected_project_ids,
        })
    );
}

#[tokio::test]
async fn repeated_mark_projects_uploaded_returns_subtree_ids_without_publishing() {
    let project_ids = vec!["root-project".to_string(), "child-project".to_string()];
    let expected_project_ids = project_ids.clone();
    let mut repo = MockProjectRepo::new();
    repo.expect_mark_projects_uploaded().return_once(|_| {
        Box::pin(async move {
            Ok(MarkedUploadedTree {
                id: "root-project".to_string(),
                name: "Uploaded tree".to_string(),
                user_id: user_id("macro|[email protected]"),
                parent_id: None,
                project_ids,
                upload_pending_transitioned: false,
            })
        })
    });
    let event_broker = TestEventBroker::default();
    let published = event_broker.published();
    let service = service_with_event_broker(repo, RecordingBulkUpload::default(), event_broker);

    let result = service
        .mark_projects_uploaded("root-project")
        .await
        .unwrap();

    assert_eq!(result, expected_project_ids);
    assert!(published.lock().unwrap().is_empty());
}

#[tokio::test]
async fn mark_projects_uploaded_missing_root_publishes_no_event() {
    let mut repo = MockProjectRepo::new();
    repo.expect_mark_projects_uploaded()
        .return_once(|_| Box::pin(async { Err(anyhow::Error::new(sqlx::Error::RowNotFound)) }));
    let event_broker = TestEventBroker::default();
    let published = event_broker.published();
    let service = service_with_event_broker(repo, RecordingBulkUpload::default(), event_broker);

    let result = service.mark_projects_uploaded("missing-project").await;

    assert!(matches!(result, Err(ProjectError::Internal(_))));
    assert!(published.lock().unwrap().is_empty());
}

#[tokio::test]
async fn mark_projects_uploaded_repository_failure_publishes_no_event() {
    let mut repo = MockProjectRepo::new();
    repo.expect_mark_projects_uploaded()
        .return_once(|_| Box::pin(async { Err(anyhow::anyhow!("database unavailable")) }));
    let event_broker = TestEventBroker::default();
    let published = event_broker.published();
    let service = service_with_event_broker(repo, RecordingBulkUpload::default(), event_broker);

    let result = service.mark_projects_uploaded("root-project").await;

    assert!(matches!(result, Err(ProjectError::Internal(_))));
    assert!(published.lock().unwrap().is_empty());
}

#[tokio::test]
async fn mark_projects_uploaded_publication_failure_is_non_fatal() {
    let mut repo = MockProjectRepo::new();
    repo.expect_mark_projects_uploaded().return_once(|_| {
        Box::pin(async {
            Ok(MarkedUploadedTree {
                id: "root-project".to_string(),
                name: "Uploaded tree".to_string(),
                user_id: user_id("macro|[email protected]"),
                parent_id: None,
                project_ids: vec!["root-project".to_string(), "child-project".to_string()],
                upload_pending_transitioned: true,
            })
        })
    });
    let service = service_with_event_broker(
        repo,
        RecordingBulkUpload::default(),
        TestEventBroker::failing(),
    );

    let result = service
        .mark_projects_uploaded("root-project")
        .await
        .unwrap();

    assert_eq!(result, vec!["root-project", "child-project"]);
}

#[tokio::test]
async fn upload_folder_publishes_uploaded_event() {
    let project_ids = vec!["root-project".to_string(), "child-project".to_string()];
    let expected_project_ids = project_ids.clone();
    let mut repo = MockProjectRepo::new();
    repo.expect_get_team_default_link_share()
        .returning(|_| Box::pin(async { Ok(None) }));
    repo.expect_upload_folder()
        .withf(|args| {
            args.user_id.as_ref() == "macro|[email protected]"
                && args.root_folder_name == "Uploaded tree"
                && args.upload_request_id == "request"
                && args.parent_id.as_deref() == Some("parent-project")
        })
        .return_once(move |_| {
            Box::pin(async move {
                Ok(UploadFolderWithIdsResponse {
                    file_system: FileSystemNodeWithIds::Folder {
                        content: Default::default(),
                        project_id: "root-project".to_string(),
                    },
                    project_ids,
                    documents: vec![upload_document("document", FileType::Pdf)],
                })
            })
        });
    let upload_urls = RecordingUploadUrls {
        calls: Arc::new(Mutex::new(Vec::new())),
        fail_document: false,
    };
    let upload_url_calls = upload_urls.calls.clone();
    let event_broker = TestEventBroker::default();
    let published = event_broker.published();
    let service = ProjectServiceImpl::new(
        repo,
        upload_urls,
        RecordingBulkUpload::default(),
        NullPort,
        NullPort,
        RecordingIndexer::default(),
        None,
        event_broker,
    );

    service
        .upload_folder(
            user_id("macro|[email protected]"),
            false,
            UploadFolderRequest {
                content: vec![FolderItem {
                    name: "document".to_string(),
                    full_name: "document.pdf".to_string(),
                    file_type: Some(FileType::Pdf),
                    relative_path: "Uploaded tree".to_string(),
                    sha: "0123456789abcdef".to_string(),
                }],
                root_folder_name: "Uploaded tree".to_string(),
                upload_request_id: "request".to_string(),
                parent_id: Some("parent-project".to_string()),
                folders: Vec::new(),
            },
        )
        .await
        .unwrap();

    assert_eq!(upload_url_calls.lock().unwrap().len(), 1);
    let published = published.lock().unwrap();
    assert_eq!(published.len(), 1);
    assert_eq!(published[0].topic, "macro.projects");
    assert_eq!(published[0].key, "root-project");
    assert_eq!(published[0].payload["schema_version"], 1);
    assert_eq!(published[0].payload["event_type"], "project.uploaded");
    assert_eq!(
        published[0].payload["metadata"],
        serde_json::json!({
            "root_project_id": "root-project",
            "owner": "macro|[email protected]",
            "name": "Uploaded tree",
            "parent_project_id": "parent-project",
            "project_ids": expected_project_ids,
        })
    );
}

#[tokio::test]
async fn upload_folder_with_no_project_ids_publishes_no_event() {
    let mut repo = MockProjectRepo::new();
    repo.expect_get_team_default_link_share()
        .returning(|_| Box::pin(async { Ok(None) }));
    repo.expect_upload_folder().return_once(|_| {
        Box::pin(async {
            Ok(UploadFolderWithIdsResponse {
                file_system: FileSystemNodeWithIds::Folder {
                    content: Default::default(),
                    project_id: "root-project".to_string(),
                },
                project_ids: Vec::new(),
                documents: Vec::new(),
            })
        })
    });
    let event_broker = TestEventBroker::default();
    let published = event_broker.published();
    let service = service_with_event_broker(repo, RecordingBulkUpload::default(), event_broker);

    service
        .upload_folder(
            user_id("macro|[email protected]"),
            false,
            UploadFolderRequest {
                content: Vec::new(),
                root_folder_name: "Uploaded tree".to_string(),
                upload_request_id: "request".to_string(),
                parent_id: None,
                folders: Vec::new(),
            },
        )
        .await
        .unwrap();

    assert!(published.lock().unwrap().is_empty());
}

#[tokio::test]
async fn upload_folder_compensates_after_destination_failure() {
    let mut repo = MockProjectRepo::new();
    repo.expect_get_team_default_link_share()
        .returning(|_| Box::pin(async { Ok(None) }));
    repo.expect_upload_folder().return_once(|_| {
        Box::pin(async {
            Ok(UploadFolderWithIdsResponse {
                file_system: FileSystemNodeWithIds::Folder {
                    content: Default::default(),
                    project_id: "project".to_string(),
                },
                project_ids: vec!["project".to_string()],
                documents: vec![upload_document("document", FileType::Pdf)],
            })
        })
    });
    repo.expect_delete_uploaded_tree()
        .withf(|projects, documents| projects == ["project"] && documents == ["document"])
        .return_once(|_, _| Box::pin(async { Ok(()) }));
    let event_broker = TestEventBroker::default();
    let published = event_broker.published();
    let service = ProjectServiceImpl::new(
        repo,
        RecordingUploadUrls {
            calls: Arc::new(Mutex::new(Vec::new())),
            fail_document: true,
        },
        RecordingBulkUpload::default(),
        NullPort,
        NullPort,
        NullPort,
        None,
        event_broker,
    );

    let result = service
        .upload_folder(
            user_id("macro|[email protected]"),
            false,
            UploadFolderRequest {
                content: vec![FolderItem {
                    name: "document".to_string(),
                    full_name: "document.pdf".to_string(),
                    file_type: Some(FileType::Pdf),
                    relative_path: "Upload".to_string(),
                    sha: "0123456789abcdef".to_string(),
                }],
                root_folder_name: "Upload".to_string(),
                upload_request_id: "request".to_string(),
                parent_id: None,
                folders: Vec::new(),
            },
        )
        .await;

    assert!(matches!(result, Err(ProjectError::Internal(_))));
    assert!(published.lock().unwrap().is_empty());
}

#[tokio::test]
async fn upload_extract_uses_fixed_request_id() {
    let fixed_id = Uuid::new_v4();
    let extract = RecordingExtract {
        request_ids: Arc::new(Mutex::new(Vec::new())),
    };
    let request_ids = extract.request_ids.clone();
    let service = ProjectServiceImpl::new(
        MockProjectRepo::new(),
        RecordingUploadUrls {
            calls: Arc::new(Mutex::new(Vec::new())),
            fail_document: false,
        },
        extract,
        NullPort,
        NullPort,
        NullPort,
        Some(fixed_id),
        TestEventBroker::default(),
    );

    let response = service
        .create_upload_extract_request(
            user_id("macro|[email protected]"),
            UploadExtractFolderRequest {
                sha: "0123456789abcdef".to_string(),
                name: Some("Upload".to_string()),
                parent_id: None,
            },
        )
        .await
        .unwrap();

    assert_eq!(response.request_id, fixed_id.to_string());
    assert_eq!(*request_ids.lock().unwrap(), vec![fixed_id]);
}

use models_permissions::share_permission::team_share::{TeamShareFacts, TeamShareLevel};

const OTHER_USER: &str = "macro|[email protected]";
const TEAM_ID: Uuid = Uuid::from_u128(0xb2222222_2222_2222_2222_222222222222);

fn owner_user() -> MacroUserIdStr<'static> {
    user_id("macro|[email protected]")
}

fn team_share_facts(
    project_id: Uuid,
    owner: MacroUserIdStr<'static>,
    owner_team_id: Option<Uuid>,
    revision: i64,
) -> TeamShareFacts {
    TeamShareFacts {
        entity: EntityType::Project.with_entity_string(project_id.to_string()),
        owner: owner.into(),
        owner_team_id,
        current: None,
        revision,
    }
}

fn team_share_args(level: Option<AccessLevel>) -> PatchProjectRequestV2 {
    PatchProjectRequestV2 {
        name: None,
        project_parent_id: None,
        share_permission: Some(UpdateSharePermissionRequestV2 {
            link_share: None,
            link_share_access_level: None,
            team_share_access_level: Some(level),
            channel_share_permissions: None,
        }),
    }
}

#[tokio::test]
async fn edit_without_team_share_field_does_not_load_facts_or_send_command() {
    let project_id = Uuid::new_v4();
    let mut repo = MockProjectRepo::new();
    repo.expect_get_team_share_facts().times(0);
    repo.expect_edit_project()
        .withf(|args| args.team_share.is_none())
        .return_once(move |_| {
            Box::pin(async move {
                Ok(project(
                    &project_id.to_string(),
                    "macro|[email protected]",
                    None,
                ))
            })
        });
    repo.expect_update_project_modified()
        .return_once(|_| Box::pin(async { Ok(()) }));
    let event_broker = TestEventBroker::default();
    let published = event_broker.published();
    let service = mutation_service_with_event_broker(
        repo,
        RecordingEam::default(),
        RecordingIndexer::default(),
        event_broker,
    );
    let mut request = patch_request(None, None);
    request.name = Some("Renamed".to_string());

    service
        .edit_project(
            mutation_receipt::<EditAccessLevel>(project_id, AccessLevel::Owner),
            basic_project(project_id, None, false),
            request,
        )
        .await
        .unwrap();

    assert_eq!(published.lock().unwrap().len(), 1);
}

#[tokio::test]
async fn edit_with_team_share_level_forwards_authorized_command() {
    let project_id = Uuid::new_v4();
    let facts = team_share_facts(project_id, owner_user(), Some(TEAM_ID), 0);
    let expected_facts = facts.clone();
    let mut repo = MockProjectRepo::new();
    repo.expect_get_team_share_facts()
        .withf(move |id| id == project_id.to_string())
        .return_once(move |_| Box::pin(async move { Ok(facts) }));
    repo.expect_edit_project()
        .withf(move |args| {
            let Some(command) = args.team_share.as_ref() else {
                return false;
            };
            command.expected() == &expected_facts
                && command.target().is_some_and(|grant| {
                    grant.team_id == TEAM_ID && grant.level == TeamShareLevel::Edit
                })
                && command.next_revision() == 1
        })
        .return_once(move |_| {
            Box::pin(async move {
                Ok(project(
                    &project_id.to_string(),
                    "macro|[email protected]",
                    None,
                ))
            })
        });
    repo.expect_update_project_modified()
        .return_once(|_| Box::pin(async { Ok(()) }));
    let event_broker = TestEventBroker::default();
    let published = event_broker.published();
    let service = mutation_service_with_event_broker(
        repo,
        RecordingEam::default(),
        RecordingIndexer::default(),
        event_broker,
    );

    service
        .edit_project(
            mutation_receipt::<EditAccessLevel>(project_id, AccessLevel::Owner),
            basic_project(project_id, None, false),
            team_share_args(Some(AccessLevel::Edit)),
        )
        .await
        .unwrap();

    let published = published.lock().unwrap();
    assert_eq!(published.len(), 1);
    assert_eq!(
        published[0].payload["metadata"]["share_permission_updated"],
        true
    );
}

#[tokio::test]
async fn edit_with_team_share_null_forwards_clear_command() {
    let project_id = Uuid::new_v4();
    let facts = team_share_facts(project_id, owner_user(), Some(TEAM_ID), 0);
    let mut repo = MockProjectRepo::new();
    repo.expect_get_team_share_facts()
        .return_once(move |_| Box::pin(async move { Ok(facts) }));
    repo.expect_edit_project()
        .withf(|args| {
            args.team_share
                .as_ref()
                .is_some_and(|command| command.target().is_none() && command.next_revision() == 1)
        })
        .return_once(move |_| {
            Box::pin(async move {
                Ok(project(
                    &project_id.to_string(),
                    "macro|[email protected]",
                    None,
                ))
            })
        });
    repo.expect_update_project_modified()
        .return_once(|_| Box::pin(async { Ok(()) }));
    let service = mutation_service(repo, RecordingEam::default(), RecordingIndexer::default());

    service
        .edit_project(
            mutation_receipt::<EditAccessLevel>(project_id, AccessLevel::Owner),
            basic_project(project_id, None, false),
            team_share_args(None),
        )
        .await
        .unwrap();
}

#[tokio::test]
async fn edit_team_share_by_non_owner_returns_unauthorized_and_publishes_nothing() {
    let project_id = Uuid::new_v4();
    let facts = team_share_facts(project_id, user_id(OTHER_USER), Some(TEAM_ID), 0);
    let mut repo = MockProjectRepo::new();
    repo.expect_get_team_share_facts()
        .return_once(move |_| Box::pin(async move { Ok(facts) }));
    repo.expect_edit_project().times(0);
    let event_broker = TestEventBroker::default();
    let published = event_broker.published();
    let service = mutation_service_with_event_broker(
        repo,
        RecordingEam::default(),
        RecordingIndexer::default(),
        event_broker,
    );

    let result = service
        .edit_project(
            mutation_receipt::<EditAccessLevel>(project_id, AccessLevel::Owner),
            basic_project(project_id, None, false),
            team_share_args(Some(AccessLevel::View)),
        )
        .await;

    assert!(matches!(result, Err(ProjectError::Unauthorized)));
    assert!(published.lock().unwrap().is_empty());
}

#[tokio::test]
async fn edit_team_share_owner_level_returns_bad_request() {
    let project_id = Uuid::new_v4();
    let facts = team_share_facts(project_id, owner_user(), Some(TEAM_ID), 0);
    let mut repo = MockProjectRepo::new();
    repo.expect_get_team_share_facts()
        .return_once(move |_| Box::pin(async move { Ok(facts) }));
    repo.expect_edit_project().times(0);
    let service = mutation_service(repo, RecordingEam::default(), RecordingIndexer::default());

    let result = service
        .edit_project(
            mutation_receipt::<EditAccessLevel>(project_id, AccessLevel::Owner),
            basic_project(project_id, None, false),
            team_share_args(Some(AccessLevel::Owner)),
        )
        .await;

    assert!(matches!(result, Err(ProjectError::BadRequest(_))));
}

#[tokio::test]
async fn edit_team_share_without_owner_team_returns_bad_request() {
    let project_id = Uuid::new_v4();
    let facts = team_share_facts(project_id, owner_user(), None, 0);
    let mut repo = MockProjectRepo::new();
    repo.expect_get_team_share_facts()
        .return_once(move |_| Box::pin(async move { Ok(facts) }));
    repo.expect_edit_project().times(0);
    let service = mutation_service(repo, RecordingEam::default(), RecordingIndexer::default());

    let result = service
        .edit_project(
            mutation_receipt::<EditAccessLevel>(project_id, AccessLevel::Owner),
            basic_project(project_id, None, false),
            team_share_args(Some(AccessLevel::Edit)),
        )
        .await;

    assert!(matches!(result, Err(ProjectError::BadRequest(_))));
}

#[tokio::test]
async fn edit_team_share_exhausted_revision_returns_conflict() {
    let project_id = Uuid::new_v4();
    let facts = team_share_facts(project_id, owner_user(), Some(TEAM_ID), i64::MAX);
    let mut repo = MockProjectRepo::new();
    repo.expect_get_team_share_facts()
        .return_once(move |_| Box::pin(async move { Ok(facts) }));
    repo.expect_edit_project().times(0);
    let service = mutation_service(repo, RecordingEam::default(), RecordingIndexer::default());

    let result = service
        .edit_project(
            mutation_receipt::<EditAccessLevel>(project_id, AccessLevel::Owner),
            basic_project(project_id, None, false),
            team_share_args(Some(AccessLevel::Edit)),
        )
        .await;

    assert!(matches!(result, Err(ProjectError::Conflict(_))));
}

#[tokio::test]
async fn edit_repo_conflict_does_not_publish_event() {
    let project_id = Uuid::new_v4();
    let facts = team_share_facts(project_id, owner_user(), Some(TEAM_ID), 0);
    let mut repo = MockProjectRepo::new();
    repo.expect_get_team_share_facts()
        .return_once(move |_| Box::pin(async move { Ok(facts) }));
    repo.expect_edit_project()
        .return_once(|_| Box::pin(async { Err(ProjectError::Conflict("stale".into())) }));
    let event_broker = TestEventBroker::default();
    let published = event_broker.published();
    let service = mutation_service_with_event_broker(
        repo,
        RecordingEam::default(),
        RecordingIndexer::default(),
        event_broker,
    );

    let result = service
        .edit_project(
            mutation_receipt::<EditAccessLevel>(project_id, AccessLevel::Owner),
            basic_project(project_id, None, false),
            team_share_args(Some(AccessLevel::Edit)),
        )
        .await;

    assert!(matches!(result, Err(ProjectError::Conflict(_))));
    assert!(published.lock().unwrap().is_empty());
}