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.

133 KB
Raw Blame
use entity_access::domain::models::MemberTeamRole;
use foreign_entity::domain::models::{
    CreateForeignEntity, ForeignEntity, ForeignEntityError, PatchForeignEntity, SourceId,
};
use foreign_entity::domain::ports::{ForeignEntityListQuery, ForeignEntityService};
use macro_event_broker::{EventBrokerError, MacroEvent, MacroEventBroker};
use macro_user_id::cowlike::CowLike;
use model::document::{DocumentMetadata, FileType};
use std::sync::{Arc, Mutex};

use crate::domain::models::{
    EmailImportRepoOutcome, GithubPullRequest, ImportEmailAttachmentRepoArgs, OwnerTeam,
    TeamTaskNumber,
};
use crate::domain::ports::{DocumentContentEventService, MockDocumentRepo};

use super::*;

mod sync_content;

fn make_test_metadata() -> DocumentMetadata {
    DocumentMetadata {
        document_id: "doc-1".to_string(),
        document_version_id: 1,
        owner: Owner::from_principal_str("macro|[email protected]").unwrap(),
        document_name: "test_doc".to_string(),
        file_type: Some("txt".to_string()),
        sha: Some("sha-1".to_string()),
        project_id: Some("project-1".to_string()),
        project_name: Some("Test Project".to_string()),
        branched_from_id: None,
        branched_from_version_id: None,
        document_family_id: None,
        document_bom: None,
        modification_data: None,
        created_at: None,
        updated_at: None,
        deleted_at: None,
        sub_type: None,
    }
}

fn make_mock_repo() -> MockDocumentRepo {
    MockDocumentRepo::new()
}

fn test_cloudfront_config() -> CloudFrontConfig {
    CloudFrontConfig {
        distribution_url: "https://cdn.example.test".to_string(),
        signer_public_key_id: "test-key-id".to_string(),
        signer_private_key: "test-private-key".to_string(),
        presigned_url_expiry_seconds: 60,
        browser_cache_expiry_seconds: 60,
    }
}

fn task_document_context(document_id: &str) -> DocumentBasic {
    DocumentBasic {
        document_id: document_id.to_string(),
        document_name: "Test task".to_string(),
        owner: Owner::from_principal_str("macro|[email protected]").unwrap(),
        file_type: Some("md".to_string()),
        sub_type: Some(DocumentSubType::Task),
        branched_from_id: None,
        branched_from_version_id: None,
        document_family_id: None,
        project_id: None,
        deleted_at: None,
    }
}

fn authenticated_receipt(document_id: &str) -> EntityAccessReceipt<ViewAccessLevel> {
    let user_id = macro_user_id::user_id::MacroUserIdStr::parse_from_str("macro|[email protected]")
        .unwrap()
        .into_owned();

    EntityAccessReceipt::dangerously_assert_authenticated_user(
        user_id,
        document_id,
        EntityType::Document,
    )
}

fn internal_receipt(document_id: &str) -> EntityAccessReceipt<ViewAccessLevel> {
    EntityAccessReceipt::dangerously_assert_internal_user(document_id, EntityType::Document)
}

fn member_team_receipt(team_id: &str, user_id: &str) -> EntityAccessReceipt<MemberTeamRole> {
    let user_id = macro_user_id::user_id::MacroUserIdStr::parse_from_str(user_id)
        .unwrap()
        .into_owned();

    EntityAccessReceipt::dangerously_assert_authenticated_user(user_id, team_id, EntityType::Team)
}

fn bot_id() -> entity_access::domain::models::BotId {
    entity_access::domain::models::BotId::new_from_uuid(uuid::uuid!(
        "00000000-0000-0000-0000-000000000123"
    ))
}

fn bot_receipt_scope() -> entity_access::domain::models::BotReceiptScope {
    entity_access::domain::models::BotReceiptScope::Team {
        team_id: uuid::uuid!("00000000-0000-0000-0000-000000000456"),
    }
}

fn bot_receipt(document_id: &str) -> EntityAccessReceipt<ViewAccessLevel> {
    EntityAccessReceipt::dangerously_assert_bot(
        bot_id().into_storage_id(),
        bot_receipt_scope(),
        document_id,
        EntityType::Document,
    )
}

struct TestUploadUrlPort;

impl PresignedUploadUrlPort for TestUploadUrlPort {
    async fn delete_object(&self, _key: &str) -> anyhow::Result<()> {
        Ok(())
    }
    async fn put_document_storage_presigned_url(
        &self,
        _key: &str,
        _sha: &str,
        _content_type: ContentType,
    ) -> anyhow::Result<String> {
        Ok(String::new())
    }

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

    async fn copy_object(&self, _source_key: &str, _destination_key: &str) -> anyhow::Result<()> {
        Ok(())
    }

    async fn get_snapshot(&self, _document_id: &str) -> anyhow::Result<Option<Vec<u8>>> {
        Ok(None)
    }

    async fn upload_snapshot(&self, _document_id: &str, _bytes: Vec<u8>) -> anyhow::Result<()> {
        Ok(())
    }
}

struct TestTaskPropertiesPort;

impl TaskPropertiesPort for TestTaskPropertiesPort {
    async fn attach_task_properties(&self, _entity_ids: Vec<String>) -> anyhow::Result<()> {
        Ok(())
    }

    async fn update_task_status(
        &self,
        _access: &EntityAccessReceipt<EditAccessLevel>,
        _credited_user: Option<&macro_user_id::user_id::MacroUserIdStr<'static>>,
        _source: Option<&models_properties::service::property_change_source::PropertyChangeSource>,
        _status: &str,
    ) -> anyhow::Result<()> {
        Ok(())
    }

    async fn set_entity_property(
        &self,
        _principal: &CreationPrincipal,
        _entity_id: &str,
        _property_definition_id: uuid::Uuid,
        _value: Option<models_properties::api::requests::SetPropertyValue>,
    ) -> anyhow::Result<()> {
        Ok(())
    }

    async fn copy_task_properties(
        &self,
        _from_task_id: &str,
        _to_task_id: &str,
    ) -> anyhow::Result<()> {
        Ok(())
    }
}

#[derive(Default)]
struct TestConnectionService {
    invalidations: Mutex<usize>,
}

impl ConnectionService for TestConnectionService {
    async fn send_invalidation_event<'a, T: std::fmt::Debug + serde::Serialize + Send>(
        &self,
        _invalidation_event: InvalidationEvent<'a, T>,
    ) -> Result<(), connection::domain::models::ConnectionError> {
        *self.invalidations.lock().unwrap() += 1;
        Ok(())
    }

    async fn send_channel_message<'a>(
        &self,
        _users: &[macro_user_id::user_id::MacroUserIdStr<'a>],
        _message_type: &str,
        _message: serde_json::Value,
    ) -> Result<(), connection::domain::models::ConnectionError> {
        Ok(())
    }
}

#[derive(Clone, Default)]
struct TestEntityAccessManagementService {
    added_to_projects: Arc<Mutex<Vec<uuid::Uuid>>>,
    removed_from_projects: Arc<Mutex<Vec<uuid::Uuid>>>,
}

impl EntityAccessManagementService for TestEntityAccessManagementService {
    async fn add_entity_to_project(
        &self,
        _entity_id: &uuid::Uuid,
        _entity_type: EntityType,
        project_id: &uuid::Uuid,
    ) -> Result<(), entity_access_management::domain::models::EntityAccessManagementError> {
        self.added_to_projects.lock().unwrap().push(*project_id);
        Ok(())
    }

    async fn remove_entity_from_project(
        &self,
        _entity_id: &uuid::Uuid,
        _entity_type: EntityType,
        old_project_id: &uuid::Uuid,
    ) -> Result<(), entity_access_management::domain::models::EntityAccessManagementError> {
        self.removed_from_projects
            .lock()
            .unwrap()
            .push(*old_project_id);
        Ok(())
    }

    async fn move_project(
        &self,
        _project_id: &uuid::Uuid,
        _old_project_id: Option<&uuid::Uuid>,
        _new_project_id: Option<&uuid::Uuid>,
    ) -> Result<(), entity_access_management::domain::models::EntityAccessManagementError> {
        Ok(())
    }
}

#[derive(Clone, Debug, Eq, PartialEq)]
struct ForeignEntityLookupRequest {
    foreign_entity_id: String,
    foreign_entity_source: Option<String>,
}

#[derive(Clone, Default)]
struct TestForeignEntityService {
    foreign_entities: Arc<Vec<ForeignEntity>>,
    lookup_requests: Arc<Mutex<Vec<ForeignEntityLookupRequest>>>,
}

impl TestForeignEntityService {
    fn new(foreign_entities: Vec<ForeignEntity>) -> Self {
        Self {
            foreign_entities: Arc::new(foreign_entities),
            lookup_requests: Arc::new(Mutex::new(Vec::new())),
        }
    }

    fn lookup_requests(&self) -> Arc<Mutex<Vec<ForeignEntityLookupRequest>>> {
        Arc::clone(&self.lookup_requests)
    }
}

impl ForeignEntityService for TestForeignEntityService {
    async fn get_foreign_entity(
        &self,
        _receipt: EntityAccessReceipt<ViewAccessLevel>,
    ) -> Result<ForeignEntity, ForeignEntityError> {
        unreachable!("test service only supports foreign entity lookups by external ID")
    }

    async fn get_foreign_entity_by_id(
        &self,
        _id: uuid::Uuid,
    ) -> Result<ForeignEntity, ForeignEntityError> {
        unreachable!("test service only supports foreign entity lookups by external ID")
    }

    async fn get_foreign_entities_by_foreign_entity_id(
        &self,
        foreign_entity_id: &str,
        foreign_entity_source: Option<&str>,
    ) -> Result<Vec<ForeignEntity>, ForeignEntityError> {
        self.lookup_requests
            .lock()
            .unwrap()
            .push(ForeignEntityLookupRequest {
                foreign_entity_id: foreign_entity_id.to_string(),
                foreign_entity_source: foreign_entity_source.map(str::to_string),
            });

        Ok(self
            .foreign_entities
            .iter()
            .filter(|foreign_entity| {
                foreign_entity.foreign_entity_id == foreign_entity_id
                    && foreign_entity_source
                        .is_none_or(|source| foreign_entity.foreign_entity_source == source)
            })
            .cloned()
            .collect())
    }

    async fn get_foreign_entities_for_user(
        &self,
        _requesting_user: Option<String>,
        _source_ids: Vec<SourceId>,
        _limit: u32,
        _query: ForeignEntityListQuery,
    ) -> Result<Vec<ForeignEntity>, ForeignEntityError> {
        unreachable!("test service only supports foreign entity lookups by external ID")
    }

    async fn create_foreign_entity(
        &self,
        _create: CreateForeignEntity,
    ) -> Result<ForeignEntity, ForeignEntityError> {
        unreachable!("test service only supports foreign entity lookups by external ID")
    }

    async fn delete_foreign_entity(&self, _id: uuid::Uuid) -> Result<(), ForeignEntityError> {
        unreachable!("test service only supports foreign entity lookups by external ID")
    }

    async fn patch_foreign_entity(
        &self,
        _id: uuid::Uuid,
        _patch: PatchForeignEntity,
    ) -> Result<ForeignEntity, ForeignEntityError> {
        unreachable!("test service only supports foreign entity lookups by external ID")
    }
}

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

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

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

    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_send {
            return Err(EventBrokerError::Publish("test broker 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(()) }))
    }
}

type TestDocumentService = DocumentServiceImpl<
    MockDocumentRepo,
    TestUploadUrlPort,
    TestTaskPropertiesPort,
    TestConnectionService,
    TestEntityAccessManagementService,
    TestForeignEntityService,
    TestEventBroker,
    sync_service_client::SyncServiceClient,
>;

fn make_test_service(repo: MockDocumentRepo) -> TestDocumentService {
    make_test_service_with_foreign_entities(repo, Vec::new())
}

fn make_test_service_with_foreign_entities(
    repo: MockDocumentRepo,
    foreign_entities: Vec<ForeignEntity>,
) -> TestDocumentService {
    make_test_service_with_foreign_entity_service(
        repo,
        TestForeignEntityService::new(foreign_entities),
    )
}

fn make_test_service_with_foreign_entity_service(
    repo: MockDocumentRepo,
    foreign_entity_service: TestForeignEntityService,
) -> TestDocumentService {
    DocumentServiceImpl::new(
        repo,
        test_cloudfront_config(),
        sync_service_client::SyncServiceClient::new(
            "test-sync-key".to_string(),
            "http://sync-service.test".to_string(),
        ),
        TestUploadUrlPort,
        TestTaskPropertiesPort,
        TestConnectionService::default(),
        TestEntityAccessManagementService::default(),
        foreign_entity_service,
        TestEventBroker::default(),
    )
}

/// Build a test service along with a handle to its recording entity access service.
fn make_test_service_with_entity_access(
    repo: MockDocumentRepo,
) -> (TestDocumentService, TestEntityAccessManagementService) {
    let entity_access = TestEntityAccessManagementService::default();
    let service = DocumentServiceImpl::new(
        repo,
        test_cloudfront_config(),
        sync_service_client::SyncServiceClient::new(
            "test-sync-key".to_string(),
            "http://sync-service.test".to_string(),
        ),
        TestUploadUrlPort,
        TestTaskPropertiesPort,
        TestConnectionService::default(),
        entity_access.clone(),
        TestForeignEntityService::default(),
        TestEventBroker::default(),
    );
    (service, entity_access)
}

/// Build a test service along with a handle to its recording event broker.
fn make_test_service_with_event_broker(
    repo: MockDocumentRepo,
) -> (TestDocumentService, TestEventBroker) {
    make_test_service_with_configured_event_broker(repo, TestEventBroker::default())
}

fn make_test_service_with_configured_event_broker(
    repo: MockDocumentRepo,
    event_broker: TestEventBroker,
) -> (TestDocumentService, TestEventBroker) {
    let service = DocumentServiceImpl::new(
        repo,
        test_cloudfront_config(),
        sync_service_client::SyncServiceClient::new(
            "test-sync-key".to_string(),
            "http://sync-service.test".to_string(),
        ),
        TestUploadUrlPort,
        TestTaskPropertiesPort,
        TestConnectionService::default(),
        TestEntityAccessManagementService::default(),
        TestForeignEntityService::default(),
        event_broker.clone(),
    );
    (service, event_broker)
}

fn make_foreign_entity(
    id: uuid::Uuid,
    foreign_entity_id: &str,
    foreign_entity_source: &str,
    stored_for_id: &str,
    stored_for_auth_entity: &str,
) -> ForeignEntity {
    let timestamp = chrono::Utc::now();

    ForeignEntity {
        id,
        foreign_entity_id: foreign_entity_id.to_string(),
        foreign_entity_source: foreign_entity_source.to_string(),
        metadata: serde_json::json!({}),
        stored_for_id: stored_for_id.to_string(),
        stored_for_auth_entity: stored_for_auth_entity.to_string(),
        created_at: timestamp,
        updated_at: timestamp,
    }
}

fn make_foreign_entity_with_metadata(
    id: uuid::Uuid,
    foreign_entity_id: &str,
    foreign_entity_source: &str,
    stored_for_id: &str,
    stored_for_auth_entity: &str,
    metadata: serde_json::Value,
) -> ForeignEntity {
    let mut foreign_entity = make_foreign_entity(
        id,
        foreign_entity_id,
        foreign_entity_source,
        stored_for_id,
        stored_for_auth_entity,
    );
    foreign_entity.metadata = metadata;
    foreign_entity
}

fn expect_authenticated_team_lookup(repo: &mut MockDocumentRepo, team_ids: Vec<uuid::Uuid>) {
    repo.expect_get_team_ids_for_user()
        .withf(|user_id| user_id == "macro|[email protected]")
        .return_once(move |_| Box::pin(std::future::ready(Ok(team_ids))));
}

fn assert_pull_request_ref(
    pull_request: &GithubPullRequest,
    github_key: &str,
    owner: &str,
    repo: &str,
    number: u64,
) {
    let expected_url = format!("https://github.com/{owner}/{repo}/pull/{number}");
    let expected_display_name = format!("{owner}/{repo}#{number}");

    assert_eq!(pull_request.github_key.as_str(), github_key);
    assert_eq!(pull_request.owner.as_str(), owner);
    assert_eq!(pull_request.repo.as_str(), repo);
    assert_eq!(pull_request.number, number);
    assert_eq!(pull_request.url.as_str(), expected_url.as_str());
    assert_eq!(
        pull_request.display_name.as_str(),
        expected_display_name.as_str()
    );
}

fn assert_no_enriched_pull_request_metadata(pull_request: &GithubPullRequest) {
    assert!(pull_request.name.is_none());
    assert!(pull_request.status.is_none());
    assert!(pull_request.additions.is_none());
    assert!(pull_request.deletions.is_none());
    assert!(pull_request.comments.is_none());
    assert!(pull_request.checks.is_none());

    let pull_request_json = serde_json::to_value(pull_request).unwrap();
    assert!(pull_request_json.get("name").is_none());
    assert!(pull_request_json.get("status").is_none());
    assert!(pull_request_json.get("additions").is_none());
    assert!(pull_request_json.get("deletions").is_none());
    assert!(pull_request_json.get("comments").is_none());
    assert!(pull_request_json.get("checks").is_none());
}

fn assert_raw_pull_request(
    pull_request: &GithubPullRequest,
    github_key: &str,
    owner: &str,
    repo: &str,
    number: u64,
) {
    assert_pull_request_ref(pull_request, github_key, owner, repo, number);
    assert!(pull_request.foreign_entity_id.is_none());
    assert_no_enriched_pull_request_metadata(pull_request);

    let pull_request_json = serde_json::to_value(pull_request).unwrap();
    assert!(pull_request_json.get("foreignEntityId").is_none());
}

fn assert_shallow_pull_request_with_foreign_entity_id(
    pull_request: &GithubPullRequest,
    github_key: &str,
    owner: &str,
    repo: &str,
    number: u64,
    foreign_entity_id: uuid::Uuid,
) {
    assert_pull_request_ref(pull_request, github_key, owner, repo, number);
    assert_eq!(pull_request.foreign_entity_id, Some(foreign_entity_id));
    assert_no_enriched_pull_request_metadata(pull_request);

    let pull_request_json = serde_json::to_value(pull_request).unwrap();
    let expected_foreign_entity_id = serde_json::json!(foreign_entity_id.to_string());
    assert_eq!(
        pull_request_json.get("foreignEntityId"),
        Some(&expected_foreign_entity_id)
    );
}

#[tokio::test]
async fn get_document_by_team_slug_resolves_valid_slug() {
    let team_id = uuid::uuid!("00000000-0000-0000-0000-000000000701");
    let mut repo = make_mock_repo();

    repo.expect_get_document_id_by_team_task_number()
        .withf(move |actual_team_id, task_num| actual_team_id == &team_id && *task_num == 42)
        .return_once(|_, _| Box::pin(std::future::ready(Ok(Some("doc-1".to_string())))));
    repo.expect_get_basic_document()
        .withf(|document_id| document_id == "doc-1")
        .return_once(|_| Box::pin(std::future::ready(Ok(task_document_context("doc-1")))));

    let document_id = make_test_service(repo)
        .get_document_by_team_slug(
            member_team_receipt(&team_id.to_string(), "macro|[email protected]"),
            "engineering-platform-42",
        )
        .await
        .unwrap();

    assert_eq!(document_id, "doc-1");
}

#[tokio::test]
async fn get_document_by_team_slug_rejects_malformed_slugs() {
    for slug in [
        "",
        "engineering",
        "-1",
        "engineering-",
        "engineering--task-1",
        "engineering-task",
        "engineering-1.5",
        "engineering-+1",
    ] {
        let mut repo = make_mock_repo();
        repo.expect_get_document_id_by_team_task_number().times(0);
        repo.expect_get_basic_document().times(0);

        let result = make_test_service(repo)
            .get_document_by_team_slug(
                member_team_receipt(
                    "00000000-0000-0000-0000-000000000701",
                    "macro|[email protected]",
                ),
                slug,
            )
            .await;

        assert!(
            matches!(result, Err(DocumentError::BadRequest(_))),
            "expected {slug:?} to be rejected, got {result:?}"
        );
    }
}

#[tokio::test]
async fn get_document_by_team_slug_rejects_non_positive_and_overflowing_numbers() {
    for slug in ["engineering-0", "engineering--1", "engineering-2147483648"] {
        let mut repo = make_mock_repo();
        repo.expect_get_document_id_by_team_task_number().times(0);
        repo.expect_get_basic_document().times(0);

        let result = make_test_service(repo)
            .get_document_by_team_slug(
                member_team_receipt(
                    "00000000-0000-0000-0000-000000000701",
                    "macro|[email protected]",
                ),
                slug,
            )
            .await;

        assert!(
            matches!(result, Err(DocumentError::BadRequest(_))),
            "expected {slug:?} to be rejected, got {result:?}"
        );
    }
}

#[tokio::test]
async fn get_document_by_team_slug_rejects_wrong_receipt_entity_type() {
    let mut repo = make_mock_repo();
    repo.expect_get_document_id_by_team_task_number().times(0);
    repo.expect_get_basic_document().times(0);
    let receipt = EntityAccessReceipt::<MemberTeamRole>::dangerously_assert_authenticated_user(
        macro_user_id::user_id::MacroUserIdStr::parse_from_str("macro|[email protected]")
            .unwrap()
            .into_owned(),
        "00000000-0000-0000-0000-000000000701",
        EntityType::Document,
    );

    let result = make_test_service(repo)
        .get_document_by_team_slug(receipt, "engineering-1")
        .await;

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

#[tokio::test]
async fn get_document_by_team_slug_rejects_malformed_team_uuid() {
    let mut repo = make_mock_repo();
    repo.expect_get_document_id_by_team_task_number().times(0);
    repo.expect_get_basic_document().times(0);

    let result = make_test_service(repo)
        .get_document_by_team_slug(
            member_team_receipt("not-a-team-uuid", "macro|[email protected]"),
            "engineering-1",
        )
        .await;

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

#[tokio::test]
async fn get_document_by_team_slug_maps_missing_lookup_to_not_found() {
    let team_id = uuid::uuid!("00000000-0000-0000-0000-000000000701");
    let mut repo = make_mock_repo();
    repo.expect_get_document_id_by_team_task_number()
        .withf(move |actual_team_id, task_num| actual_team_id == &team_id && *task_num == 404)
        .return_once(|_, _| Box::pin(std::future::ready(Ok(None))));
    repo.expect_get_basic_document().times(0);

    let result = make_test_service(repo)
        .get_document_by_team_slug(
            member_team_receipt(&team_id.to_string(), "macro|[email protected]"),
            "engineering-404",
        )
        .await;

    assert!(matches!(
        result,
        Err(DocumentError::NotFound(slug)) if slug == "engineering-404"
    ));
}

#[tokio::test]
async fn get_document_by_team_slug_maps_lookup_error_to_internal() {
    let team_id = uuid::uuid!("00000000-0000-0000-0000-000000000701");
    let mut repo = make_mock_repo();
    repo.expect_get_document_id_by_team_task_number()
        .return_once(|_, _| Box::pin(std::future::ready(Err(anyhow!("database unavailable")))));
    repo.expect_get_basic_document().times(0);

    let result = make_test_service(repo)
        .get_document_by_team_slug(
            member_team_receipt(&team_id.to_string(), "macro|[email protected]"),
            "engineering-1",
        )
        .await;

    assert!(matches!(result, Err(DocumentError::Internal(_))));
}

#[tokio::test]
async fn get_document_by_team_slug_maps_document_load_error_to_internal() {
    let team_id = uuid::uuid!("00000000-0000-0000-0000-000000000701");
    let mut repo = make_mock_repo();
    repo.expect_get_document_id_by_team_task_number()
        .return_once(|_, _| Box::pin(std::future::ready(Ok(Some("doc-1".to_string())))));
    repo.expect_get_basic_document()
        .return_once(|_| Box::pin(std::future::ready(Err(anyhow!("database unavailable")))));

    let result = make_test_service(repo)
        .get_document_by_team_slug(
            member_team_receipt(&team_id.to_string(), "macro|[email protected]"),
            "engineering-1",
        )
        .await;

    assert!(matches!(result, Err(DocumentError::Internal(_))));
}

#[tokio::test]
async fn get_document_by_team_slug_allows_owner_of_deleted_document() {
    let team_id = uuid::uuid!("00000000-0000-0000-0000-000000000701");
    let mut document = task_document_context("doc-1");
    document.deleted_at = Some(chrono::Utc::now());
    let mut repo = make_mock_repo();
    repo.expect_get_document_id_by_team_task_number()
        .return_once(|_, _| Box::pin(std::future::ready(Ok(Some("doc-1".to_string())))));
    repo.expect_get_basic_document()
        .return_once(move |_| Box::pin(std::future::ready(Ok(document))));

    let result = make_test_service(repo)
        .get_document_by_team_slug(
            member_team_receipt(&team_id.to_string(), "macro|[email protected]"),
            "engineering-1",
        )
        .await;

    assert_eq!(result.unwrap(), "doc-1");
}

#[tokio::test]
async fn get_document_by_team_slug_rejects_non_owner_of_deleted_document() {
    let team_id = uuid::uuid!("00000000-0000-0000-0000-000000000701");
    let mut document = task_document_context("doc-1");
    document.deleted_at = Some(chrono::Utc::now());
    let mut repo = make_mock_repo();
    repo.expect_get_document_id_by_team_task_number()
        .return_once(|_, _| Box::pin(std::future::ready(Ok(Some("doc-1".to_string())))));
    repo.expect_get_basic_document()
        .return_once(move |_| Box::pin(std::future::ready(Ok(document))));

    let result = make_test_service(repo)
        .get_document_by_team_slug(
            member_team_receipt(&team_id.to_string(), "macro|[email protected]"),
            "engineering-1",
        )
        .await;

    assert!(matches!(result, Err(DocumentError::Unauthorized)));
}

#[tokio::test]
async fn bot_document_has_no_saved_user_view_location() {
    let mut repo = make_mock_repo();
    let metadata = make_test_metadata();

    repo.expect_get_document_metadata()
        .return_once(move |_| Box::pin(std::future::ready(Ok(metadata))));
    repo.expect_get_user_view_location().times(0);
    repo.expect_get_persisted_document_content()
        .return_once(|_| {
            Box::pin(std::future::ready(Ok(Some(DocumentContent::ready(
                DocumentContentLocation::ObjectStorage,
            )))))
        });
    repo.expect_get_team_task_metadata()
        .return_once(|_| Box::pin(std::future::ready(Ok(None))));

    let response = make_test_service(repo)
        .get_document(bot_receipt("doc-1"))
        .await
        .unwrap();

    assert_eq!(response.view_location, None);
}

#[tokio::test]
async fn bot_lifecycle_event_has_no_actor_user_id() {
    let mut repo = make_mock_repo();
    repo.expect_get_document_metadata()
        .returning(|_| Box::pin(std::future::ready(Ok(make_test_metadata()))));
    repo.expect_soft_delete_document()
        .withf(|id| id == "doc-1")
        .return_once(|_| Box::pin(std::future::ready(Ok(()))));

    let (service, event_broker) = make_test_service_with_event_broker(repo);
    let receipt = EntityAccessReceipt::<OwnerAccessLevel>::dangerously_assert_bot(
        bot_id().into_storage_id(),
        bot_receipt_scope(),
        "doc-1",
        EntityType::Document,
    );

    service.delete_document(receipt, None).await.unwrap();

    let published = event_broker.published();
    let published = published.lock().unwrap();
    assert_eq!(published.len(), 1);
    assert_eq!(
        published[0].payload["metadata"]["actor_user_id"],
        serde_json::Value::Null
    );
}

#[tokio::test]
async fn bot_task_branch_uses_macro_fallback() {
    let document_id = "00000000-0000-0000-0000-000000000124";
    let service = make_test_service(make_mock_repo());

    let response = service
        .get_task_branch_name(bot_receipt(document_id), "Fix bot auth".to_string())
        .await
        .unwrap();

    assert_eq!(
        response.branch_name,
        build_task_branch_name(
            "macro",
            None,
            None,
            &short_id_for_entity_id(document_id).unwrap(),
            "Fix bot auth",
        )
    );
}

#[tokio::test]
async fn test_get_document_happy_path() {
    let mut repo = make_mock_repo();
    let metadata = make_test_metadata();
    let metadata_clone = metadata.clone();

    repo.expect_get_document_metadata()
        .withf(|id| id == "doc-1")
        .returning(move |_| Box::pin(std::future::ready(Ok(metadata_clone.clone()))));

    repo.expect_get_user_view_location()
        .withf(|uid, did| uid == "user-1" && did == "doc-1")
        .returning(|_, _| Box::pin(std::future::ready(Ok(Some("page-3".to_string())))));

    // We can't easily construct the full service because it needs SyncServiceClient + PgPool.
    // Instead, test the repo interaction directly via the trait.
    let result = repo.get_document_metadata("doc-1").await.unwrap();
    assert_eq!(result.document_id, "doc-1");
    assert_eq!(result.document_name, "test_doc");

    let view_loc = repo
        .get_user_view_location("user-1", "doc-1")
        .await
        .unwrap();
    assert_eq!(view_loc, Some("page-3".to_string()));
}

#[tokio::test]
async fn test_get_document_not_found() {
    let mut repo = make_mock_repo();

    repo.expect_get_document_metadata()
        .withf(|id| id == "nonexistent")
        .returning(|_| {
            Box::pin(std::future::ready(Err(anyhow!(
                "no rows returned by a query that expected to return at least one row"
            ))))
        });

    let result = repo.get_document_metadata("nonexistent").await;
    assert!(result.is_err());
    assert!(result.unwrap_err().to_string().contains("no rows returned"));
}

#[tokio::test]
async fn test_soft_delete_document() {
    let mut repo = make_mock_repo();

    repo.expect_soft_delete_document()
        .withf(|id| id == "doc-1")
        .returning(|_| Box::pin(std::future::ready(Ok(()))));

    let result = repo.soft_delete_document("doc-1").await;
    assert!(result.is_ok());
}

#[tokio::test]
async fn bot_pull_request_does_not_hydrate_foreign_entity() {
    let document_id = "00000000-0000-0000-0000-000000000125";
    let expected_short_id = short_id_for_entity_id(document_id).unwrap();
    let foreign_entity_id = uuid::uuid!("00000000-0000-0000-0000-000000000126");
    let mut repo = make_mock_repo();

    repo.expect_get_task_github_pull_request_keys()
        .withf(move |task_short_id| task_short_id == expected_short_id)
        .return_once(|_| {
            Box::pin(std::future::ready(Ok(vec![
                "macro/repo/pull/17".to_string(),
            ])))
        });

    let service = make_test_service_with_foreign_entities(
        repo,
        vec![make_foreign_entity(
            foreign_entity_id,
            "macro/repo/pull/17",
            GITHUB_PULL_REQUEST_FOREIGN_ENTITY_SOURCE,
            bot_id().into_storage_id().as_ref(),
            "bot",
        )],
    );

    let response = service
        .get_task_github_pull_requests(
            bot_receipt(document_id),
            &task_document_context(document_id),
        )
        .await
        .unwrap();

    assert_eq!(response.pull_requests.len(), 1);
    assert_raw_pull_request(
        &response.pull_requests[0],
        "macro/repo/pull/17",
        "macro",
        "repo",
        17,
    );
}

#[tokio::test]
async fn test_get_task_github_pull_requests_returns_raw_refs_for_authenticated_user() {
    let document_id = "00000000-0000-0000-0000-000000000001";
    let expected_short_id = short_id_for_entity_id(document_id).unwrap();
    let mut repo = make_mock_repo();

    repo.expect_get_task_github_pull_request_keys()
        .withf(move |task_short_id| task_short_id == expected_short_id)
        .return_once(|_| {
            Box::pin(std::future::ready(Ok(vec![
                "macro/repo/pull/7".to_string(),
            ])))
        });
    expect_authenticated_team_lookup(&mut repo, Vec::new());

    let service = make_test_service(repo);

    let response = service
        .get_task_github_pull_requests(
            authenticated_receipt(document_id),
            &task_document_context(document_id),
        )
        .await
        .unwrap();

    assert_eq!(response.pull_requests.len(), 1);
    assert_raw_pull_request(
        &response.pull_requests[0],
        "macro/repo/pull/7",
        "macro",
        "repo",
        7,
    );
}

#[tokio::test]
async fn test_get_task_github_pull_requests_adds_user_foreign_entity_id() {
    let document_id = "00000000-0000-0000-0000-000000000002";
    let expected_short_id = short_id_for_entity_id(document_id).unwrap();
    let foreign_entity_id = uuid::uuid!("00000000-0000-0000-0000-000000000101");
    let mut repo = make_mock_repo();

    repo.expect_get_task_github_pull_request_keys()
        .withf(move |task_short_id| task_short_id == expected_short_id)
        .return_once(|_| {
            Box::pin(std::future::ready(Ok(vec![
                "macro/repo/pull/8".to_string(),
            ])))
        });
    expect_authenticated_team_lookup(&mut repo, Vec::new());

    let service = make_test_service_with_foreign_entities(
        repo,
        vec![make_foreign_entity(
            foreign_entity_id,
            "macro/repo/pull/8",
            GITHUB_PULL_REQUEST_FOREIGN_ENTITY_SOURCE,
            "macro|[email protected]",
            "user",
        )],
    );

    let response = service
        .get_task_github_pull_requests(
            authenticated_receipt(document_id),
            &task_document_context(document_id),
        )
        .await
        .unwrap();

    assert_eq!(response.pull_requests.len(), 1);
    assert_pull_request_ref(
        &response.pull_requests[0],
        "macro/repo/pull/8",
        "macro",
        "repo",
        8,
    );
    assert_eq!(
        response.pull_requests[0].foreign_entity_id,
        Some(foreign_entity_id)
    );
}

#[tokio::test]
async fn test_get_task_github_pull_requests_hydrates_visible_foreign_entity_metadata() {
    let document_id = "00000000-0000-0000-0000-000000000008";
    let expected_short_id = short_id_for_entity_id(document_id).unwrap();
    let foreign_entity_id = uuid::uuid!("00000000-0000-0000-0000-000000000501");
    let mut repo = make_mock_repo();

    repo.expect_get_task_github_pull_request_keys()
        .withf(move |task_short_id| task_short_id == expected_short_id)
        .return_once(|_| {
            Box::pin(std::future::ready(Ok(vec![
                "macro/repo/pull/14".to_string(),
            ])))
        });
    expect_authenticated_team_lookup(&mut repo, Vec::new());

    let metadata = serde_json::json!({
        "githubKey": "macro/repo/pull/14",
        "owner": "macro",
        "repo": "repo",
        "number": 14,
        "url": "https://github.com/macro/repo/pull/14",
        "displayName": "macro/repo#14",
        "name": "Hydrate GitHub pull request metadata",
        "status": "open",
        "additions": 120,
        "deletions": 34,
        "comments": [
            {
                "id": 9001,
                "body": "Looks ready to merge.",
                "authorLogin": "alice",
                "authorAssociation": "MEMBER",
                "url": "https://github.com/macro/repo/pull/14#issuecomment-9001",
                "createdAt": "2026-06-09T12:00:00Z",
                "updatedAt": "2026-06-09T12:05:00Z",
                "source": "issue_comment"
            }
        ],
        "checks": [
            {
                "id": 7001,
                "name": "ci/test",
                "status": "completed",
                "conclusion": "success",
                "url": "https://github.com/macro/repo/actions/runs/7001",
                "startedAt": "2026-06-09T11:00:00Z",
                "completedAt": "2026-06-09T11:03:00Z"
            }
        ]
    });

    let service = make_test_service_with_foreign_entities(
        repo,
        vec![make_foreign_entity_with_metadata(
            foreign_entity_id,
            "macro/repo/pull/14",
            GITHUB_PULL_REQUEST_FOREIGN_ENTITY_SOURCE,
            "macro|[email protected]",
            "user",
            metadata.clone(),
        )],
    );

    let response = service
        .get_task_github_pull_requests(
            authenticated_receipt(document_id),
            &task_document_context(document_id),
        )
        .await
        .unwrap();

    assert_eq!(response.pull_requests.len(), 1);
    let mut expected_pull_request = metadata;
    expected_pull_request.as_object_mut().unwrap().insert(
        "foreignEntityId".to_string(),
        serde_json::json!(foreign_entity_id.to_string()),
    );
    assert_eq!(
        serde_json::to_value(&response.pull_requests[0]).unwrap(),
        expected_pull_request
    );
}

#[tokio::test]
async fn test_get_task_github_pull_requests_falls_back_when_foreign_entity_metadata_is_malformed() {
    let document_id = "00000000-0000-0000-0000-000000000009";
    let expected_short_id = short_id_for_entity_id(document_id).unwrap();
    let malformed_foreign_entity_id = uuid::uuid!("00000000-0000-0000-0000-000000000601");
    let mismatched_foreign_entity_id = uuid::uuid!("00000000-0000-0000-0000-000000000602");
    let mut repo = make_mock_repo();

    repo.expect_get_task_github_pull_request_keys()
        .withf(move |task_short_id| task_short_id == expected_short_id)
        .return_once(|_| {
            Box::pin(std::future::ready(Ok(vec![
                "macro/repo/pull/15".to_string(),
                "macro/repo/pull/16".to_string(),
            ])))
        });
    expect_authenticated_team_lookup(&mut repo, Vec::new());

    let service = make_test_service_with_foreign_entities(
        repo,
        vec![
            make_foreign_entity_with_metadata(
                malformed_foreign_entity_id,
                "macro/repo/pull/15",
                GITHUB_PULL_REQUEST_FOREIGN_ENTITY_SOURCE,
                "macro|[email protected]",
                "user",
                serde_json::json!({
                    "githubKey": "macro/repo/pull/15",
                    "owner": "macro"
                }),
            ),
            make_foreign_entity_with_metadata(
                mismatched_foreign_entity_id,
                "macro/repo/pull/16",
                GITHUB_PULL_REQUEST_FOREIGN_ENTITY_SOURCE,
                "macro|[email protected]",
                "user",
                serde_json::json!({
                    "githubKey": "macro/repo/pull/999",
                    "owner": "macro",
                    "repo": "repo",
                    "number": 999,
                    "url": "https://github.com/macro/repo/pull/999",
                    "displayName": "macro/repo#999",
                    "name": "Wrong pull request metadata",
                    "status": "merged",
                    "additions": 999,
                    "deletions": 999,
                    "comments": [],
                    "checks": []
                }),
            ),
        ],
    );

    let response = service
        .get_task_github_pull_requests(
            authenticated_receipt(document_id),
            &task_document_context(document_id),
        )
        .await
        .unwrap();

    assert_eq!(response.pull_requests.len(), 2);
    assert_shallow_pull_request_with_foreign_entity_id(
        &response.pull_requests[0],
        "macro/repo/pull/15",
        "macro",
        "repo",
        15,
        malformed_foreign_entity_id,
    );
    assert_shallow_pull_request_with_foreign_entity_id(
        &response.pull_requests[1],
        "macro/repo/pull/16",
        "macro",
        "repo",
        16,
        mismatched_foreign_entity_id,
    );
}

#[tokio::test]
async fn test_get_task_github_pull_requests_adds_team_foreign_entity_id() {
    let document_id = "00000000-0000-0000-0000-000000000003";
    let expected_short_id = short_id_for_entity_id(document_id).unwrap();
    let team_id = uuid::uuid!("00000000-0000-0000-0000-000000000201");
    let foreign_entity_id = uuid::uuid!("00000000-0000-0000-0000-000000000202");
    let mut repo = make_mock_repo();

    repo.expect_get_task_github_pull_request_keys()
        .withf(move |task_short_id| task_short_id == expected_short_id)
        .return_once(|_| {
            Box::pin(std::future::ready(Ok(vec![
                "macro/repo/pull/9".to_string(),
            ])))
        });
    expect_authenticated_team_lookup(&mut repo, vec![team_id]);

    let service = make_test_service_with_foreign_entities(
        repo,
        vec![make_foreign_entity(
            foreign_entity_id,
            "macro/repo/pull/9",
            GITHUB_PULL_REQUEST_FOREIGN_ENTITY_SOURCE,
            &team_id.to_string(),
            "team",
        )],
    );

    let response = service
        .get_task_github_pull_requests(
            authenticated_receipt(document_id),
            &task_document_context(document_id),
        )
        .await
        .unwrap();

    assert_eq!(response.pull_requests.len(), 1);
    assert_pull_request_ref(
        &response.pull_requests[0],
        "macro/repo/pull/9",
        "macro",
        "repo",
        9,
    );
    assert_eq!(
        response.pull_requests[0].foreign_entity_id,
        Some(foreign_entity_id)
    );
}

#[tokio::test]
async fn test_get_task_github_pull_requests_ignores_unrelated_foreign_entity_source() {
    let document_id = "00000000-0000-0000-0000-000000000004";
    let expected_short_id = short_id_for_entity_id(document_id).unwrap();
    let unrelated_foreign_entity_id = uuid::uuid!("00000000-0000-0000-0000-000000000301");
    let mut repo = make_mock_repo();

    repo.expect_get_task_github_pull_request_keys()
        .withf(move |task_short_id| task_short_id == expected_short_id)
        .return_once(|_| {
            Box::pin(std::future::ready(Ok(vec![
                "macro/repo/pull/10".to_string(),
            ])))
        });
    expect_authenticated_team_lookup(&mut repo, Vec::new());

    let foreign_entity_service = TestForeignEntityService::new(vec![make_foreign_entity(
        unrelated_foreign_entity_id,
        "macro/repo/pull/10",
        "linear_issue",
        "macro|[email protected]",
        "user",
    )]);
    let lookup_requests = foreign_entity_service.lookup_requests();
    let service = make_test_service_with_foreign_entity_service(repo, foreign_entity_service);

    let response = service
        .get_task_github_pull_requests(
            authenticated_receipt(document_id),
            &task_document_context(document_id),
        )
        .await
        .unwrap();

    assert_eq!(response.pull_requests.len(), 1);
    assert_raw_pull_request(
        &response.pull_requests[0],
        "macro/repo/pull/10",
        "macro",
        "repo",
        10,
    );
    assert_eq!(
        *lookup_requests.lock().unwrap(),
        vec![ForeignEntityLookupRequest {
            foreign_entity_id: "macro/repo/pull/10".to_string(),
            foreign_entity_source: Some(GITHUB_PULL_REQUEST_FOREIGN_ENTITY_SOURCE.to_string()),
        }]
    );
}

#[tokio::test]
async fn test_get_task_github_pull_requests_ignores_unrelated_stored_source() {
    let document_id = "00000000-0000-0000-0000-000000000005";
    let expected_short_id = short_id_for_entity_id(document_id).unwrap();
    let unrelated_foreign_entity_id = uuid::uuid!("00000000-0000-0000-0000-000000000401");
    let mut repo = make_mock_repo();

    repo.expect_get_task_github_pull_request_keys()
        .withf(move |task_short_id| task_short_id == expected_short_id)
        .return_once(|_| {
            Box::pin(std::future::ready(Ok(vec![
                "macro/repo/pull/11".to_string(),
            ])))
        });
    expect_authenticated_team_lookup(&mut repo, Vec::new());

    let service = make_test_service_with_foreign_entities(
        repo,
        vec![make_foreign_entity_with_metadata(
            unrelated_foreign_entity_id,
            "macro/repo/pull/11",
            GITHUB_PULL_REQUEST_FOREIGN_ENTITY_SOURCE,
            "macro|[email protected]",
            "user",
            serde_json::json!({
                "githubKey": "macro/repo/pull/11",
                "owner": "macro",
                "repo": "repo",
                "number": 11,
                "url": "https://github.com/macro/repo/pull/11",
                "displayName": "macro/repo#11",
                "name": "Invisible pull request metadata",
                "status": "open",
                "additions": 55,
                "deletions": 13,
                "comments": [
                    {
                        "id": 3001,
                        "body": "This comment should not be visible.",
                        "authorLogin": "mallory",
                        "authorAssociation": "CONTRIBUTOR",
                        "url": "https://github.com/macro/repo/pull/11#issuecomment-3001",
                        "createdAt": "2026-06-09T10:00:00Z",
                        "updatedAt": "2026-06-09T10:01:00Z",
                        "source": "issue_comment"
                    }
                ],
                "checks": [
                    {
                        "id": 3002,
                        "name": "ci/private",
                        "status": "completed",
                        "conclusion": "failure",
                        "url": "https://github.com/macro/repo/actions/runs/3002",
                        "startedAt": "2026-06-09T09:00:00Z",
                        "completedAt": "2026-06-09T09:04:00Z"
                    }
                ]
            }),
        )],
    );

    let response = service
        .get_task_github_pull_requests(
            authenticated_receipt(document_id),
            &task_document_context(document_id),
        )
        .await
        .unwrap();

    assert_eq!(response.pull_requests.len(), 1);
    assert_raw_pull_request(
        &response.pull_requests[0],
        "macro/repo/pull/11",
        "macro",
        "repo",
        11,
    );
}

#[tokio::test]
async fn test_get_task_github_pull_requests_returns_raw_refs_for_internal_access() {
    let document_id = "00000000-0000-0000-0000-000000000006";
    let expected_short_id = short_id_for_entity_id(document_id).unwrap();
    let mut repo = make_mock_repo();

    repo.expect_get_task_github_pull_request_keys()
        .withf(move |task_short_id| task_short_id == expected_short_id)
        .return_once(|_| {
            Box::pin(std::future::ready(Ok(vec![
                "macro/repo/pull/12".to_string(),
            ])))
        });

    let service = make_test_service(repo);

    let response = service
        .get_task_github_pull_requests(
            internal_receipt(document_id),
            &task_document_context(document_id),
        )
        .await
        .unwrap();

    assert_eq!(response.pull_requests.len(), 1);
    assert_raw_pull_request(
        &response.pull_requests[0],
        "macro/repo/pull/12",
        "macro",
        "repo",
        12,
    );
}

#[tokio::test]
async fn test_get_task_github_pull_requests_skips_malformed_keys_before_lookup() {
    let document_id = "00000000-0000-0000-0000-000000000007";
    let expected_short_id = short_id_for_entity_id(document_id).unwrap();
    let mut repo = make_mock_repo();

    repo.expect_get_task_github_pull_request_keys()
        .withf(move |task_short_id| task_short_id == expected_short_id)
        .return_once(|_| {
            Box::pin(std::future::ready(Ok(vec![
                "not-a-pr-key".to_string(),
                "macro/repo/pull/13".to_string(),
            ])))
        });

    let foreign_entity_service = TestForeignEntityService::default();
    let lookup_requests = foreign_entity_service.lookup_requests();
    let service = make_test_service_with_foreign_entity_service(repo, foreign_entity_service);

    let response = service
        .get_task_github_pull_requests(
            internal_receipt(document_id),
            &task_document_context(document_id),
        )
        .await
        .unwrap();

    assert_eq!(response.pull_requests.len(), 1);
    assert_raw_pull_request(
        &response.pull_requests[0],
        "macro/repo/pull/13",
        "macro",
        "repo",
        13,
    );
    assert_eq!(
        *lookup_requests.lock().unwrap(),
        vec![ForeignEntityLookupRequest {
            foreign_entity_id: "macro/repo/pull/13".to_string(),
            foreign_entity_source: Some(GITHUB_PULL_REQUEST_FOREIGN_ENTITY_SOURCE.to_string()),
        }]
    );
}

fn owner_receipt(document_id: &str) -> EntityAccessReceipt<OwnerAccessLevel> {
    let user_id = macro_user_id::user_id::MacroUserIdStr::parse_from_str("macro|[email protected]")
        .unwrap()
        .into_owned();

    EntityAccessReceipt::dangerously_assert_authenticated_user(
        user_id,
        document_id,
        EntityType::Document,
    )
}

fn team_share_facts() -> models_permissions::share_permission::team_share::TeamShareFacts {
    let owner = task_document_context("doc-1").owner;
    models_permissions::share_permission::team_share::TeamShareFacts {
        entity: EntityType::Document.with_entity_str("doc-1"),
        owner,
        owner_team_id: Some(uuid::Uuid::from_u128(1)),
        current: None,
        revision: 0,
    }
}

#[tokio::test]
async fn team_toggle_rejects_non_owner_without_writes_or_events() {
    let mut repo = make_mock_repo();
    repo.expect_get_team_share_facts()
        .returning(|_| Box::pin(async { Ok(team_share_facts()) }));
    let (service, broker) = make_test_service_with_event_broker(repo);
    let result = service.set_team_share(edit_receipt("doc-1"), true).await;
    assert!(matches!(result, Err(DocumentError::Unauthorized)));
    assert!(broker.published().lock().unwrap().is_empty());
}

fn team_edit_args(
    level: Option<models_permissions::share_permission::access_level::AccessLevel>,
) -> EditDocumentServiceArgs {
    EditDocumentServiceArgs {
        document_name: Some("renamed".to_string()),
        project_id: None,
        file_type: None,
        share_permission: Some(UpdateSharePermissionRequestV2 {
            team_share_access_level: Some(level),
            link_share: None,
            link_share_access_level: None,
            channel_share_permissions: None,
        }),
    }
}

fn team_policy_receipts() -> Vec<EntityAccessReceipt<EditAccessLevel>> {
    use entity_access::domain::models::{AccessLevel, Entity, EntityPermission};
    let entity = Entity {
        entity_id: "doc-1".to_string(),
        entity_type: EntityType::Document,
    };
    let non_owner = edit_receipt("doc-1").acting_user_id().unwrap().clone();
    let mut receipts = Vec::new();
    for access_level in [AccessLevel::Edit, AccessLevel::Owner] {
        receipts.push(
            EntityAccessReceipt::try_new_authenticated_user(
                non_owner.clone(),
                entity.clone(),
                EntityPermission::AccessLevel { access_level },
            )
            .unwrap(),
        );
    }
    receipts.push(
        EntityAccessReceipt::try_new_bot(
            bot_id().into_storage_id(),
            bot_receipt_scope(),
            entity.clone(),
            EntityPermission::AccessLevel {
                access_level: AccessLevel::Owner,
            },
        )
        .unwrap(),
    );
    for auth in [
        EntityAccessAuth::Internal,
        EntityAccessAuth::Unauthenticated,
    ] {
        receipts.push(
            EntityAccessReceipt::try_new(
                auth,
                entity.clone(),
                EntityPermission::AccessLevel {
                    access_level: AccessLevel::Owner,
                },
            )
            .unwrap(),
        );
    }
    receipts
}

#[tokio::test]
async fn team_policy_rejects_editors_inherited_owners_and_identityless_receipts() {
    use models_permissions::share_permission::access_level::AccessLevel;
    for level in [
        Some(AccessLevel::View),
        Some(AccessLevel::Comment),
        Some(AccessLevel::Edit),
        None,
    ] {
        for receipt in team_policy_receipts() {
            let mut repo = make_mock_repo();
            repo.expect_get_team_share_facts()
                .returning(|_| Box::pin(async { Ok(team_share_facts()) }));
            let (service, broker) = make_test_service_with_event_broker(repo);
            // Even a context claiming the actor owns it cannot replace persisted facts.
            let mut context = task_document_context("doc-1");
            context.owner = Owner::User(edit_receipt("doc-1").acting_user_id().unwrap().clone());
            assert!(matches!(
                service
                    .edit_document(receipt, context, team_edit_args(level))
                    .await,
                Err(DocumentError::Unauthorized)
            ));
            assert!(broker.published().lock().unwrap().is_empty());
        }
    }
    for enabled in [true, false] {
        for receipt in team_policy_receipts() {
            let mut repo = make_mock_repo();
            repo.expect_get_team_share_facts()
                .returning(|_| Box::pin(async { Ok(team_share_facts()) }));
            assert!(matches!(
                make_test_service(repo)
                    .set_team_share(receipt, enabled)
                    .await,
                Err(DocumentError::Unauthorized)
            ));
        }
    }
}

fn owner_bot_edit_receipt() -> EntityAccessReceipt<EditAccessLevel> {
    use entity_access::domain::models::{AccessLevel, Entity, EntityPermission};
    EntityAccessReceipt::try_new_bot(
        bot_id().into_storage_id(),
        BotReceiptScope::User {
            acting_user: team_share_facts().owner.as_user().unwrap().clone(),
        },
        Entity {
            entity_id: "doc-1".to_string(),
            entity_type: EntityType::Document,
        },
        EntityPermission::AccessLevel {
            access_level: AccessLevel::Edit,
        },
    )
    .unwrap()
}

#[tokio::test]
async fn owner_scoped_bot_can_edit_and_toggle_explicit_team_sharing() {
    use models_permissions::share_permission::access_level::AccessLevel;
    for level in [
        Some(AccessLevel::View),
        Some(AccessLevel::Comment),
        Some(AccessLevel::Edit),
        None,
    ] {
        let mut repo = make_mock_repo();
        repo.expect_get_team_share_facts()
            .returning(|_| Box::pin(async { Ok(team_share_facts()) }));
        repo.expect_edit_document()
            .times(1)
            .withf(move |args| {
                let command = args.team_share.as_ref().unwrap();
                command.expected() == &team_share_facts()
                    && command.target().map(|grant| AccessLevel::from(grant.level)) == level
            })
            .returning(|_| Box::pin(async { Ok(()) }));
        make_test_service(repo)
            .edit_document(
                owner_bot_edit_receipt(),
                task_document_context("doc-1"),
                team_edit_args(level),
            )
            .await
            .unwrap();
    }
    for enabled in [true, false] {
        let mut repo = make_mock_repo();
        repo.expect_get_team_share_facts()
            .returning(|_| Box::pin(async { Ok(team_share_facts()) }));
        repo.expect_set_team_share()
            .times(1)
            .withf(move |command| command.target().is_some() == enabled)
            .returning(move |_| {
                Box::pin(async move {
                    Ok(super::super::models::DocumentTeamShare {
                        team_id: team_share_facts().owner_team_id,
                        shared_with_team: enabled,
                    })
                })
            });
        make_test_service(repo)
            .set_team_share(owner_bot_edit_receipt(), enabled)
            .await
            .unwrap();
    }
}

#[tokio::test]
async fn team_edit_conflict_does_not_publish_success() {
    let mut repo = make_mock_repo();
    repo.expect_get_team_share_facts()
        .returning(|_| Box::pin(async { Ok(team_share_facts()) }));
    repo.expect_edit_document()
        .returning(|_| Box::pin(async { Err(DocumentError::Conflict("stale facts".to_string())) }));
    let (service, broker) = make_test_service_with_event_broker(repo);
    assert!(matches!(
        service
            .edit_document(
                owner_bot_edit_receipt(),
                task_document_context("doc-1"),
                team_edit_args(None)
            )
            .await,
        Err(DocumentError::Conflict(_))
    ));
    assert!(broker.published().lock().unwrap().is_empty());
    assert_eq!(*service.connection_service.invalidations.lock().unwrap(), 0);
}

#[tokio::test]
async fn team_toggle_conflict_does_not_invalidate() {
    let mut repo = make_mock_repo();
    repo.expect_get_team_share_facts()
        .returning(|_| Box::pin(async { Ok(team_share_facts()) }));
    repo.expect_set_team_share()
        .returning(|_| Box::pin(async { Err(DocumentError::Conflict("stale facts".to_string())) }));
    let service = make_test_service(repo);
    assert!(matches!(
        service.set_team_share(owner_bot_edit_receipt(), true).await,
        Err(DocumentError::Conflict(_))
    ));
    assert_eq!(*service.connection_service.invalidations.lock().unwrap(), 0);
}

#[tokio::test]
async fn team_edit_rejects_owner_level_and_enable_without_team_before_writes() {
    use models_permissions::share_permission::access_level::AccessLevel;
    for (level, has_team) in [(AccessLevel::Owner, true), (AccessLevel::View, false)] {
        let mut repo = make_mock_repo();
        repo.expect_get_team_share_facts().returning(move |_| {
            Box::pin(async move {
                let mut facts = team_share_facts();
                if !has_team {
                    facts.owner_team_id = None;
                }
                Ok(facts)
            })
        });
        let service = make_test_service(repo);
        assert!(matches!(
            service
                .edit_document(
                    owner_bot_edit_receipt(),
                    task_document_context("doc-1"),
                    team_edit_args(Some(level))
                )
                .await,
            Err(DocumentError::BadRequest(_))
        ));
        assert_eq!(*service.connection_service.invalidations.lock().unwrap(), 0);
    }
}

fn edit_receipt(document_id: &str) -> EntityAccessReceipt<EditAccessLevel> {
    let user_id = macro_user_id::user_id::MacroUserIdStr::parse_from_str("macro|[email protected]")
        .unwrap()
        .into_owned();

    EntityAccessReceipt::dangerously_assert_authenticated_user(
        user_id,
        document_id,
        EntityType::Document,
    )
}

#[tokio::test]
async fn content_uploaded_publishes_document_event_with_owner_and_version() {
    let mut repo = make_mock_repo();
    repo.expect_get_basic_document()
        .withf(|document_id| document_id == "doc-1")
        .return_once(|_| Box::pin(std::future::ready(Ok(task_document_context("doc-1")))));

    let (service, event_broker) = make_test_service_with_event_broker(repo);

    service
        .publish_content_uploaded("doc-1", FileType::Pdf, Some("convert".to_string()))
        .await
        .unwrap();

    let published = event_broker.published();
    let published = published.lock().unwrap();
    assert_eq!(published.len(), 1);
    let event = &published[0];
    assert_eq!(event.topic, "macro.documents");
    assert_eq!(event.key, "doc-1");
    assert_eq!(event.payload["event_type"], "document.content_uploaded");
    assert_eq!(event.payload["metadata"]["document_id"], "doc-1");
    assert_eq!(event.payload["metadata"]["owner"], "macro|[email protected]");
    assert_eq!(event.payload["metadata"]["file_type"], "pdf");
    assert_eq!(event.payload["metadata"]["document_version_id"], "convert");
}

#[tokio::test]
async fn content_uploaded_preserves_an_absent_version() {
    let mut repo = make_mock_repo();
    repo.expect_get_basic_document()
        .return_once(|_| Box::pin(std::future::ready(Ok(task_document_context("doc-1")))));

    let (service, event_broker) = make_test_service_with_event_broker(repo);

    service
        .publish_content_uploaded("doc-1", FileType::Pdf, None)
        .await
        .unwrap();

    let published = event_broker.published();
    let published = published.lock().unwrap();
    assert_eq!(
        published[0].payload["metadata"]["document_version_id"],
        serde_json::Value::Null
    );
}

#[tokio::test]
async fn content_uploaded_maps_a_missing_document_to_not_found() {
    let mut repo = make_mock_repo();
    repo.expect_get_basic_document().return_once(|_| {
        Box::pin(std::future::ready(Err(anyhow!(
            "no rows returned by a query that expected to return at least one row"
        ))))
    });

    let (service, event_broker) = make_test_service_with_event_broker(repo);
    let result = service
        .publish_content_uploaded("missing-doc", FileType::Pdf, None)
        .await;

    assert!(matches!(
        result,
        Err(DocumentError::NotFound(document_id)) if document_id == "missing-doc"
    ));
    assert!(event_broker.published().lock().unwrap().is_empty());
}

#[tokio::test]
async fn content_uploaded_maps_an_immediate_broker_failure_to_internal() {
    let mut repo = make_mock_repo();
    repo.expect_get_basic_document()
        .return_once(|_| Box::pin(std::future::ready(Ok(task_document_context("doc-1")))));
    let event_broker = TestEventBroker::failing();
    let (service, event_broker) =
        make_test_service_with_configured_event_broker(repo, event_broker);

    let result = service
        .publish_content_uploaded("doc-1", FileType::Pdf, None)
        .await;

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

#[tokio::test]
async fn test_delete_document_publishes_document_deleted_event() {
    let mut repo = make_mock_repo();
    repo.expect_get_document_metadata().returning(|_| {
        let mut metadata = make_test_metadata();
        metadata.sub_type = Some(DocumentSubType::Task);
        Box::pin(std::future::ready(Ok(metadata)))
    });
    repo.expect_soft_delete_document()
        .withf(|id| id == "doc-1")
        .returning(|_| Box::pin(std::future::ready(Ok(()))));
    repo.expect_update_project_modified()
        .withf(|id| id == "project-1")
        .returning(|_| Box::pin(std::future::ready(Ok(()))));

    let (service, event_broker) = make_test_service_with_event_broker(repo);

    service
        .delete_document(owner_receipt("doc-1"), Some("project-1".to_string()))
        .await
        .unwrap();

    let published = event_broker.published();
    let published = published.lock().unwrap();
    assert_eq!(published.len(), 1);
    let event = &published[0];
    assert_eq!(event.topic, "macro.documents");
    assert_eq!(event.key, "doc-1");
    assert_eq!(event.payload["event_type"], "document.deleted");
    assert_eq!(event.payload["schema_version"], 1);
    assert_eq!(event.payload["metadata"]["document_id"], "doc-1");
    assert_eq!(event.payload["metadata"]["sub_type"], "task");
    assert_eq!(
        event.payload["metadata"]["actor_user_id"],
        "macro|[email protected]"
    );
    assert_eq!(event.payload["metadata"]["project_id"], "project-1");
    assert!(
        uuid::Uuid::parse_str(event.payload["event_id"].as_str().unwrap()).is_ok(),
        "event_id should be a valid uuid: {:?}",
        event.payload["event_id"]
    );
}

#[tokio::test]
async fn test_delete_document_publishes_no_event_when_repo_fails() {
    let mut repo = make_mock_repo();
    repo.expect_get_document_metadata()
        .returning(|_| Box::pin(std::future::ready(Ok(make_test_metadata()))));
    repo.expect_soft_delete_document()
        .withf(|id| id == "doc-1")
        .returning(|_| Box::pin(std::future::ready(Err(anyhow!("db is down")))));

    let (service, event_broker) = make_test_service_with_event_broker(repo);

    let result = service.delete_document(owner_receipt("doc-1"), None).await;

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

#[tokio::test]
async fn delete_document_rejects_initiative_description() {
    let mut repo = make_mock_repo();
    let mut metadata = make_test_metadata();
    metadata.sub_type = Some(DocumentSubType::InitiativeDescription);
    repo.expect_get_document_metadata()
        .return_once(move |_| Box::pin(std::future::ready(Ok(metadata))));
    repo.expect_soft_delete_document().times(0);

    let (service, event_broker) = make_test_service_with_event_broker(repo);
    let result = service.delete_document(owner_receipt("doc-1"), None).await;

    assert!(matches!(result, Err(DocumentError::BadRequest(_))));
    assert!(event_broker.published().lock().unwrap().is_empty());
}

#[tokio::test]
async fn edit_document_sets_revocation_intent_from_link_share_target() {
    for (link_share, expected_revocation) in [
        (Some(Some(LinkShare::Team)), true),
        (Some(None), true),
        (Some(Some(LinkShare::Public)), false),
        (None, false),
    ] {
        let mut repo = make_mock_repo();
        repo.expect_edit_document()
            .withf(move |args| {
                args.revoke_non_owner_user_access == expected_revocation
                    && args
                        .share_permission
                        .as_ref()
                        .is_some_and(|permission| permission.link_share == link_share)
            })
            .return_once(|_| Box::pin(std::future::ready(Ok(()))));

        make_test_service(repo)
            .edit_document(
                edit_receipt("doc-1"),
                task_document_context("doc-1"),
                EditDocumentServiceArgs {
                    document_name: None,
                    project_id: None,
                    share_permission: Some(UpdateSharePermissionRequestV2 {
                        link_share,
                        link_share_access_level: None,
                        team_share_access_level: None,
                        channel_share_permissions: None,
                    }),
                    file_type: None,
                },
            )
            .await
            .unwrap();
    }
}

#[tokio::test]
async fn test_edit_document_publishes_document_updated_event() {
    let mut repo = make_mock_repo();
    repo.expect_edit_document()
        .withf(|args| args.document_id == "doc-1" && !args.revoke_non_owner_user_access)
        .returning(|_| Box::pin(std::future::ready(Ok(()))));

    let (service, event_broker) = make_test_service_with_event_broker(repo);

    service
        .edit_document(
            edit_receipt("doc-1"),
            task_document_context("doc-1"),
            EditDocumentServiceArgs {
                document_name: Some("New name.md".to_string()),
                project_id: None,
                share_permission: None,
                file_type: None,
            },
        )
        .await
        .unwrap();

    let published = event_broker.published();
    let published = published.lock().unwrap();
    assert_eq!(published.len(), 1);
    let event = &published[0];
    assert_eq!(event.topic, "macro.documents");
    assert_eq!(event.key, "doc-1");
    assert_eq!(event.payload["event_type"], "document.updated");
    assert_eq!(event.payload["metadata"]["document_name"], "New name");
    assert_eq!(event.payload["metadata"]["owner"], "macro|[email protected]");
    assert_eq!(
        event.payload["metadata"]["actor_user_id"],
        "macro|[email protected]"
    );
    assert_eq!(event.payload["metadata"]["share_permission_updated"], false);
    assert_eq!(
        event.payload["metadata"]["previous_project_id"],
        serde_json::Value::Null
    );
    assert_eq!(
        event.payload["metadata"]["project_id"],
        serde_json::Value::Null
    );
}

#[tokio::test]
async fn test_edit_document_rename_only_keeps_project_access() {
    let document_id = uuid::Uuid::new_v4().to_string();
    let old_project_id = uuid::Uuid::new_v4();

    let mut repo = make_mock_repo();
    repo.expect_edit_document()
        .returning(|_| Box::pin(std::future::ready(Ok(()))));

    let (service, entity_access) = make_test_service_with_entity_access(repo);

    let mut context = task_document_context(&document_id);
    context.project_id = Some(old_project_id.to_string());

    service
        .edit_document(
            edit_receipt(&document_id),
            context,
            EditDocumentServiceArgs {
                document_name: Some("New name".to_string()),
                project_id: None,
                share_permission: None,
                file_type: None,
            },
        )
        .await
        .unwrap();

    assert!(
        entity_access
            .removed_from_projects
            .lock()
            .unwrap()
            .is_empty()
    );
    assert!(entity_access.added_to_projects.lock().unwrap().is_empty());
}

#[tokio::test]
async fn test_edit_document_project_change_moves_project_access() {
    let document_id = uuid::Uuid::new_v4().to_string();
    let old_project_id = uuid::Uuid::new_v4();
    let new_project_id = uuid::Uuid::new_v4();

    let mut repo = make_mock_repo();
    repo.expect_edit_document()
        .returning(|_| Box::pin(std::future::ready(Ok(()))));
    repo.expect_update_project_modified()
        .times(2)
        .returning(|_| Box::pin(std::future::ready(Ok(()))));

    let (service, entity_access) = make_test_service_with_entity_access(repo);

    let mut context = task_document_context(&document_id);
    context.project_id = Some(old_project_id.to_string());

    service
        .edit_document(
            edit_receipt(&document_id),
            context,
            EditDocumentServiceArgs {
                document_name: None,
                project_id: Some(new_project_id.to_string()),
                share_permission: None,
                file_type: None,
            },
        )
        .await
        .unwrap();

    assert_eq!(
        *entity_access.removed_from_projects.lock().unwrap(),
        vec![old_project_id]
    );
    assert_eq!(
        *entity_access.added_to_projects.lock().unwrap(),
        vec![new_project_id]
    );
}

#[tokio::test]
async fn copy_document_best_effort_bumps_inherited_project_and_publishes_event() {
    let mut repo = make_mock_repo();
    let original_metadata = make_test_metadata();
    let original_for_lookup = original_metadata.clone();
    repo.expect_get_document_metadata()
        .withf(|id| id == "doc-1")
        .returning(move |_| Box::pin(std::future::ready(Ok(original_for_lookup.clone()))));
    repo.expect_get_project_owner()
        .withf(|id| id == "project-1")
        .returning(|_| {
            Box::pin(std::future::ready(Ok(
                macro_user_id::user_id::MacroUserIdStr::parse_from_str("macro|[email protected]")
                    .unwrap()
                    .into_owned(),
            )))
        });
    let mut copied_metadata = make_test_metadata();
    copied_metadata.document_id = "doc-2".to_string();
    copied_metadata.document_name = "copied doc".to_string();
    repo.expect_get_owner_team()
        .returning(|_| Box::pin(std::future::ready(Ok(None))));
    repo.expect_copy_document()
        .returning(move |_, _| Box::pin(std::future::ready(Ok(copied_metadata.clone()))));
    repo.expect_get_document_version_id()
        .returning(|_| Box::pin(std::future::ready(Ok((1, true)))));
    repo.expect_get_latest_document_version_id()
        .returning(|_| Box::pin(std::future::ready(Ok((1, true)))));
    repo.expect_set_document_content()
        .returning(|_, _| Box::pin(std::future::ready(Ok(()))));
    repo.expect_update_project_modified()
        .withf(|project_id| project_id == "project-1")
        .times(1)
        .returning(|_| Box::pin(std::future::ready(Err(anyhow!("db is down")))));
    repo.expect_get_team_task_metadata()
        .returning(|_| Box::pin(std::future::ready(Ok(None))));

    let (service, event_broker) = make_test_service_with_event_broker(repo);

    let mut document_context = task_document_context("doc-1");
    document_context.file_type = Some("txt".to_string());
    document_context.sub_type = None;

    service
        .copy_document(
            authenticated_receipt("doc-1"),
            document_context,
            &CreationPrincipal::User(test_user()),
            "copied doc".to_string(),
            None,
            None,
        )
        .await
        .unwrap();

    let published = event_broker.published();
    let published = published.lock().unwrap();
    assert_eq!(published.len(), 1);
    let event = &published[0];
    assert_eq!(event.topic, "macro.documents");
    assert_eq!(event.key, "doc-2");
    assert_eq!(event.payload["event_type"], "document.copied");
    assert_eq!(event.payload["metadata"]["document_id"], "doc-2");
    assert_eq!(event.payload["metadata"]["source_document_id"], "doc-1");
    assert_eq!(event.payload["metadata"]["document_name"], "copied doc");
    assert_eq!(event.payload["metadata"]["owner"], "macro|[email protected]");
}

#[derive(Clone, Default)]
struct RecordingUploadUrlPort {
    copies: Arc<Mutex<Vec<(String, String)>>>,
    deletions: Arc<Mutex<Vec<String>>>,
    uploads: Arc<Mutex<Vec<(String, String)>>>,
    fail_delete: bool,
}

impl PresignedUploadUrlPort for RecordingUploadUrlPort {
    async fn delete_object(&self, key: &str) -> anyhow::Result<()> {
        self.deletions.lock().unwrap().push(key.to_string());
        if self.fail_delete {
            anyhow::bail!("storage cleanup unavailable");
        }
        Ok(())
    }
    async fn put_document_storage_presigned_url(
        &self,
        key: &str,
        sha: &str,
        _content_type: ContentType,
    ) -> anyhow::Result<String> {
        self.uploads
            .lock()
            .unwrap()
            .push((key.to_string(), sha.to_string()));
        Ok(String::new())
    }

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

    async fn copy_object(&self, source_key: &str, destination_key: &str) -> anyhow::Result<()> {
        self.copies
            .lock()
            .unwrap()
            .push((source_key.to_string(), destination_key.to_string()));
        Ok(())
    }

    async fn get_snapshot(&self, _document_id: &str) -> anyhow::Result<Option<Vec<u8>>> {
        Ok(None)
    }

    async fn upload_snapshot(&self, _document_id: &str, _bytes: Vec<u8>) -> anyhow::Result<()> {
        Ok(())
    }
}

#[tokio::test]
async fn bot_owned_copy_reads_the_source_owner_key_and_writes_the_bot_key() {
    let principal = CreationPrincipal::TeamBot {
        bot: bot_id::NonSystemBotId::new(bot_id()).unwrap(),
        team: uuid::uuid!("00000000-0000-0000-0000-000000000456"),
    };

    for (file_type, source_key, destination_key) in [
        (
            "txt",
            "macro|[email protected]/doc-1/1",
            "bot|00000000-0000-0000-0000-000000000123/doc-2/3",
        ),
        (
            "docx",
            "macro|[email protected]/doc-1/converted.pdf",
            "bot|00000000-0000-0000-0000-000000000123/doc-2/converted.pdf",
        ),
    ] {
        let mut original = make_test_metadata();
        original.project_id = None;
        original.project_name = None;
        original.file_type = Some(file_type.to_string());
        original.document_bom = Some(serde_json::json!([]));
        let mut repo = make_mock_repo();
        repo.expect_get_document_metadata()
            .returning(move |_| Box::pin(std::future::ready(Ok(original.clone()))));
        repo.expect_get_owner_team()
            .returning(|_| Box::pin(std::future::ready(Ok(None))));
        repo.expect_copy_document().returning(|args, _| {
            let mut copied = make_test_metadata();
            copied.document_id = "doc-2".to_string();
            copied.document_version_id = 3;
            copied.owner = args.owner;
            copied.project_id = None;
            Box::pin(std::future::ready(Ok(copied)))
        });
        repo.expect_get_document_version_id()
            .returning(|_| Box::pin(std::future::ready(Ok((1, true)))));
        repo.expect_get_latest_document_version_id()
            .returning(|_| Box::pin(std::future::ready(Ok((1, true)))));
        repo.expect_set_document_content()
            .returning(|_, _| Box::pin(std::future::ready(Ok(()))));
        repo.expect_get_team_task_metadata()
            .returning(|_| Box::pin(std::future::ready(Ok(None))));
        let uploads = RecordingUploadUrlPort::default();
        let service = DocumentServiceImpl::new(
            repo,
            test_cloudfront_config(),
            sync_service_client::SyncServiceClient::new(
                "test-sync-key".to_string(),
                "http://sync-service.test".to_string(),
            ),
            uploads.clone(),
            TestTaskPropertiesPort,
            TestConnectionService::default(),
            TestEntityAccessManagementService::default(),
            TestForeignEntityService::default(),
            TestEventBroker::default(),
        );
        let mut context = task_document_context("doc-1");
        context.file_type = Some(file_type.to_string());
        context.sub_type = None;

        service
            .copy_document(
                bot_receipt("doc-1"),
                context,
                &principal,
                "copied doc".to_string(),
                None,
                None,
            )
            .await
            .unwrap();

        assert_eq!(
            *uploads.copies.lock().unwrap(),
            [(source_key.to_string(), destination_key.to_string())]
        );
    }
}

struct RejectUnexpectedFinalization;

impl crate::domain::ports::markdown::MarkdownInitializationPort for RejectUnexpectedFinalization {
    async fn initialize_existing_markdown(
        &self,
        _: &str,
        _: &str,
    ) -> Result<Vec<u8>, DocumentError> {
        panic!("failed repository creation must not initialize markdown");
    }

    async fn initialize_existing_notion(
        &self,
        _: &str,
        _: &crate::domain::notion_markdown::NotionMarkdown,
    ) -> Result<crate::domain::ports::markdown::MarkdownSnapshot, DocumentError> {
        panic!("failed repository creation must not initialize markdown");
    }
}

impl crate::domain::ports::create::DocumentBytesUploadPort for RejectUnexpectedFinalization {
    async fn upload_document_bytes(
        &self,
        _: crate::domain::ports::create::DocumentBytesUpload,
    ) -> Result<(), DocumentError> {
        panic!("failed repository creation must not upload content");
    }
}

impl crate::domain::ports::mentions::DocumentMentionTrackingPort for RejectUnexpectedFinalization {
    async fn track_document_mentions(
        &self,
        _: &str,
        _: Option<&macro_user_id::user_id::MacroUserIdStr<'static>>,
        _: &str,
    ) -> anyhow::Result<()> {
        panic!("failed repository creation must not track mentions");
    }
}

#[tokio::test]
async fn creator_forwards_explicit_consent_and_stops_after_repository_failure() {
    use crate::domain::create::{
        DocumentCreator, MarkdownSubtype, NewDocumentMetadata, NewMarkdownTextDocument,
    };

    for (subtype, expected_share) in [
        (MarkdownSubtype::Note, false),
        (MarkdownSubtype::Snippet, false),
        (
            MarkdownSubtype::from_task_flag(true, Some(uuid::Uuid::from_u128(7))),
            true,
        ),
        (
            MarkdownSubtype::Task {
                property_values: None,
                share_with_team: false,
                team_id: None,
            },
            false,
        ),
    ] {
        let mut repo = make_mock_repo();
        repo.expect_get_owner_team()
            .returning(|_| Box::pin(std::future::ready(Ok(None))));
        repo.expect_create_document()
            .withf(move |args, permission| {
                args.document.share_with_team == expected_share
                    && permission.team_share_access_level.is_none()
            })
            .times(1)
            .returning(|_, _| {
                Box::pin(std::future::ready(Err(DocumentError::Internal(
                    anyhow::anyhow!("creation rolled back"),
                ))))
            });
        let (service, event_broker) = make_test_service_with_event_broker(repo);
        let creator = DocumentCreator::new(
            service,
            RejectUnexpectedFinalization,
            RejectUnexpectedFinalization,
            RejectUnexpectedFinalization,
        );
        let result = creator
            .create_markdown_text(
                &CreationPrincipal::User(test_user()),
                NewMarkdownTextDocument {
                    metadata: NewDocumentMetadata::new("test"),
                    markdown: String::new(),
                    subtype,
                },
            )
            .await;
        assert!(result.is_err());
        assert!(event_broker.published().lock().unwrap().is_empty());
    }
}

fn test_user() -> MacroUserIdStr<'static> {
    MacroUserIdStr::parse_from_str("macro|[email protected]")
        .unwrap()
        .into_owned()
}

fn new_document(file_type: FileType) -> NewDocument {
    NewDocument {
        id: None,
        sha: "sha".to_string(),
        document_name: "doc".to_string(),
        file_type: Some(file_type),
        project_id: None,
        team_id: None,
        share_with_team: false,
        created_at: None,
        updated_at: None,
        sub_type: None,
        skip_history: false,
        initial_link_share: InitialLinkShare::EntityDefault,
    }
}

#[tokio::test]
async fn team_bot_task_rejects_a_different_numbering_team() {
    let mut repo = make_mock_repo();
    repo.expect_get_owner_team().times(0);
    repo.expect_create_document().times(0);
    let (service, broker) = make_test_service_with_event_broker(repo);
    let team = uuid::Uuid::from_u128(7);
    let principal = CreationPrincipal::TeamBot {
        bot: bot_id::NonSystemBotId::new(bot_id::BotId::TEST_A).unwrap(),
        team,
    };
    let mut document = new_document(FileType::Md);
    document.sub_type = Some(DocumentSubType::Task);
    document.team_id = Some(uuid::Uuid::from_u128(8));

    let error = crate::domain::ports::DocumentService::create_document(
        &service, &principal, document, None,
    )
    .await
    .unwrap_err();

    assert_eq!(
        error.to_string(),
        "bad request: task team does not match the creating bot's team"
    );
    assert!(broker.published().lock().unwrap().is_empty());
}

async fn create_document_with_team_default(
    team_default: Option<models_permissions::share_permission::TeamLinkShareDefault>,
    file_type: FileType,
    expected_link_share: Option<models_permissions::share_permission::LinkShare>,
    expected_access_level: Option<models_permissions::share_permission::access_level::AccessLevel>,
) {
    let mut repo = make_mock_repo();
    repo.expect_get_owner_team()
        .withf(|owner| *owner == Owner::User(test_user()))
        .returning(move |_| {
            Box::pin(std::future::ready(Ok(team_default.map(
                |default_link_share| OwnerTeam {
                    team_id: uuid::Uuid::from_u128(1),
                    default_link_share,
                },
            ))))
        });
    let created_metadata = make_test_metadata();
    repo.expect_create_document()
        .withf(move |_, share_permission| {
            share_permission.link_share == expected_link_share
                && share_permission.link_share_access_level == expected_access_level
        })
        .times(1)
        .returning(move |_, _| Box::pin(std::future::ready(Ok(created_metadata.clone()))));
    repo.expect_set_document_content()
        .returning(|_, _| Box::pin(std::future::ready(Ok(()))));
    repo.expect_get_team_task_metadata()
        .returning(|_| Box::pin(std::future::ready(Ok(None))));

    let (service, _event_broker) = make_test_service_with_event_broker(repo);

    crate::domain::ports::DocumentService::create_document(
        &service,
        &CreationPrincipal::User(test_user()),
        new_document(file_type),
        None,
    )
    .await
    .unwrap();
}

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

    // Team scope applies; a non-md doc has no entity level so it falls back to View.
    create_document_with_team_default(
        Some(TeamLinkShareDefault(Some(LinkShare::Team))),
        FileType::Txt,
        Some(LinkShare::Team),
        Some(AccessLevel::View),
    )
    .await;

    // Md keeps its Edit level under a team scope.
    create_document_with_team_default(
        Some(TeamLinkShareDefault(Some(LinkShare::Team))),
        FileType::Md,
        Some(LinkShare::Team),
        Some(AccessLevel::Edit),
    )
    .await;
}

#[tokio::test]
async fn create_document_repo_receives_entity_default_without_team() {
    use models_permissions::share_permission::LinkShare;
    use models_permissions::share_permission::access_level::AccessLevel;

    create_document_with_team_default(
        None,
        FileType::Md,
        Some(LinkShare::Public),
        Some(AccessLevel::Edit),
    )
    .await;
    create_document_with_team_default(None, FileType::Txt, None, None).await;
}

#[tokio::test]
async fn create_document_repo_receives_disabled_share_when_team_turned_link_share_off() {
    use models_permissions::share_permission::TeamLinkShareDefault;

    create_document_with_team_default(Some(TeamLinkShareDefault(None)), FileType::Md, None, None)
        .await;
}

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

    for state in [
        LinkShareState::Off,
        LinkShareState::On {
            scope: LinkShare::Team,
            level: AccessLevel::View,
        },
    ] {
        let mut repo = make_mock_repo();
        let created_metadata = make_test_metadata();
        repo.expect_get_owner_team().times(0);
        repo.expect_create_document()
            .withf(move |args, share_permission| {
                args.document.initial_link_share == InitialLinkShare::Exact(state)
                    && share_permission.link_share_state() == state
                    && share_permission.team_share_access_level.is_none()
            })
            .times(1)
            .returning(move |_, _| Box::pin(std::future::ready(Ok(created_metadata.clone()))));
        repo.expect_set_document_content()
            .returning(|_, _| Box::pin(std::future::ready(Ok(()))));
        repo.expect_get_team_task_metadata()
            .returning(|_| Box::pin(std::future::ready(Ok(None))));
        let (service, _event_broker) = make_test_service_with_event_broker(repo);

        let mut document = new_document(FileType::Md);
        document.initial_link_share = InitialLinkShare::Exact(state);
        crate::domain::ports::DocumentService::create_document(
            &service,
            &CreationPrincipal::User(test_user()),
            document,
            None,
        )
        .await
        .unwrap();
    }
}

#[tokio::test]
async fn initiative_description_rejects_entity_default_link_share() {
    let repo = make_mock_repo();
    let (service, event_broker) = make_test_service_with_event_broker(repo);
    let mut document = new_document(FileType::Md);
    document.sub_type = Some(document_sub_type::DocumentSubType::InitiativeDescription);

    let err = crate::domain::ports::DocumentService::create_document(
        &service,
        &CreationPrincipal::User(test_user()),
        document,
        None,
    )
    .await
    .unwrap_err();

    assert_eq!(
        err.to_string(),
        "bad request: initiative descriptions must set an exact initial link share"
    );
    assert!(event_broker.published().lock().unwrap().is_empty());
}

#[tokio::test]
async fn initiative_description_accepts_exact_link_share() {
    use models_permissions::share_permission::LinkShareState;

    let mut repo = make_mock_repo();
    let created_metadata = make_test_metadata();
    repo.expect_get_owner_team().times(0);
    repo.expect_create_document()
        .withf(|args, share_permission| {
            args.document.sub_type
                == Some(document_sub_type::DocumentSubType::InitiativeDescription)
                && args.document.initial_link_share == InitialLinkShare::Exact(LinkShareState::Off)
                && share_permission.link_share_state() == LinkShareState::Off
        })
        .times(1)
        .returning(move |_, _| Box::pin(std::future::ready(Ok(created_metadata.clone()))));
    repo.expect_set_document_content()
        .returning(|_, _| Box::pin(std::future::ready(Ok(()))));
    repo.expect_get_team_task_metadata()
        .returning(|_| Box::pin(std::future::ready(Ok(None))));
    let (service, _event_broker) = make_test_service_with_event_broker(repo);

    let mut document = new_document(FileType::Md);
    document.sub_type = Some(document_sub_type::DocumentSubType::InitiativeDescription);
    document.initial_link_share = InitialLinkShare::Exact(LinkShareState::Off);
    crate::domain::ports::DocumentService::create_document(
        &service,
        &CreationPrincipal::User(test_user()),
        document,
        None,
    )
    .await
    .unwrap();
}

#[tokio::test]
async fn create_document_publishes_the_principal_as_owner_and_actor() {
    let team_bot = CreationPrincipal::TeamBot {
        bot: bot_id::NonSystemBotId::new(bot_id::BotId::TEST_A).unwrap(),
        team: uuid::Uuid::from_u128(7),
    };
    for (principal, owner, actor, on_behalf_of) in [
        (
            CreationPrincipal::User(test_user()),
            "macro|[email protected]",
            "macro|[email protected]",
            None,
        ),
        (
            CreationPrincipal::BotForUser {
                bot: bot_id::MACRO_AI_BOT_ID,
                user: test_user(),
            },
            "macro|[email protected]",
            "bot|00000000-0000-0000-0000-00000000a1a1",
            Some("macro|[email protected]"),
        ),
        (
            team_bot,
            "bot|00000000-0000-0000-0000-00000000b07a",
            "bot|00000000-0000-0000-0000-00000000b07a",
            None,
        ),
    ] {
        let mut repo = make_mock_repo();
        repo.expect_get_owner_team()
            .returning(|_| Box::pin(std::future::ready(Ok(None))));
        repo.expect_create_document().returning(|args, _| {
            let mut metadata = make_test_metadata();
            metadata.owner = args.owner;
            Box::pin(std::future::ready(Ok(metadata)))
        });
        repo.expect_set_document_content()
            .returning(|_, _| Box::pin(std::future::ready(Ok(()))));
        repo.expect_get_team_task_metadata()
            .returning(|_| Box::pin(std::future::ready(Ok(None))));
        let (service, event_broker) = make_test_service_with_event_broker(repo);

        crate::domain::ports::DocumentService::create_document(
            &service,
            &principal,
            new_document(FileType::Txt),
            None,
        )
        .await
        .unwrap();

        let published = event_broker.published();
        let published = published.lock().unwrap();
        let metadata = &published[0].payload["metadata"];
        assert_eq!(metadata["owner"], owner);
        assert_eq!(metadata["actor"], actor);
        assert_eq!(
            metadata.get("on_behalf_of").and_then(|user| user.as_str()),
            on_behalf_of
        );
    }
}

#[tokio::test]
async fn email_import_is_attributed_to_the_system_bot() {
    let mut repo = make_mock_repo();
    repo.expect_get_owner_team()
        .returning(|_| Box::pin(std::future::ready(Ok(None))));
    let created_metadata = make_test_metadata();
    repo.expect_import_email_attachment_document()
        .returning(move |_, _| {
            Box::pin(std::future::ready(Ok(EmailImportRepoOutcome::Created(
                created_metadata.clone(),
            ))))
        });
    repo.expect_set_document_content()
        .returning(|_, _| Box::pin(std::future::ready(Ok(()))));
    repo.expect_get_team_task_metadata()
        .returning(|_| Box::pin(std::future::ready(Ok(None))));

    let (service, event_broker) = make_test_service_with_event_broker(repo);
    let args = ImportEmailAttachmentRepoArgs {
        email_attachment_id: uuid::Uuid::from_u128(7),
        owner: test_user(),
        document: new_document(FileType::Txt),
    };

    crate::domain::ports::DocumentService::import_email_attachment(&service, args)
        .await
        .unwrap();

    let published = event_broker.published();
    let published = published.lock().unwrap();
    assert_eq!(published[0].payload["event_type"], "document.created");
    assert_eq!(
        published[0].payload["metadata"]["owner"],
        "macro|[email protected]"
    );
    assert_eq!(
        published[0].payload["metadata"]["actor"],
        bot_id::MACRO_SYSTEM_BOT_ID.into_storage_id().as_ref()
    );
    assert!(
        published[0].payload["metadata"]
            .get("on_behalf_of")
            .is_none()
    );
}

type PropertyWrite = (CreationPrincipal, uuid::Uuid, Option<SetPropertyValue>);

#[derive(Default, Clone)]
struct RecordingTaskPropertiesPort {
    writes: Arc<Mutex<Vec<PropertyWrite>>>,
}

impl TaskPropertiesPort for RecordingTaskPropertiesPort {
    async fn attach_task_properties(&self, _entity_ids: Vec<String>) -> anyhow::Result<()> {
        Ok(())
    }

    async fn update_task_status(
        &self,
        _access: &EntityAccessReceipt<EditAccessLevel>,
        _credited_user: Option<&macro_user_id::user_id::MacroUserIdStr<'static>>,
        _source: Option<&models_properties::service::property_change_source::PropertyChangeSource>,
        _status: &str,
    ) -> anyhow::Result<()> {
        Ok(())
    }

    async fn set_entity_property(
        &self,
        principal: &CreationPrincipal,
        _entity_id: &str,
        property_definition_id: uuid::Uuid,
        value: Option<SetPropertyValue>,
    ) -> anyhow::Result<()> {
        self.writes
            .lock()
            .unwrap()
            .push((principal.clone(), property_definition_id, value));
        Ok(())
    }

    async fn copy_task_properties(
        &self,
        _from_task_id: &str,
        _to_task_id: &str,
    ) -> anyhow::Result<()> {
        Ok(())
    }
}

#[tokio::test]
async fn default_task_properties_assign_the_acting_user_and_never_a_team_bot() {
    let assignees = uuid::Uuid::parse_str(ASSIGNEES_PROPERTY_ID).unwrap();
    let status = uuid::Uuid::parse_str(STATUS_PROPERTY_ID).unwrap();
    let not_started = SetPropertyValue::SelectOption {
        option_id: NOT_STARTED_STATUS_OPTION_ID,
    };
    let assigned_to_user = SetPropertyValue::MultiEntityReference {
        references: vec![EntityReference {
            entity_id: "macro|[email protected]".to_string(),
            entity_type: models_properties::EntityType::User,
            specific_message_id: None,
        }],
    };
    let bot_for_user = CreationPrincipal::BotForUser {
        bot: bot_id::MACRO_SYSTEM_BOT_ID,
        user: test_user(),
    };
    let team_bot = CreationPrincipal::TeamBot {
        bot: bot_id::NonSystemBotId::new(bot_id::BotId::TEST_A).unwrap(),
        team: uuid::Uuid::from_u128(7),
    };

    for (principal, expected) in [
        (
            bot_for_user,
            vec![
                (assignees, Some(assigned_to_user)),
                (status, Some(not_started.clone())),
            ],
        ),
        (team_bot, vec![(status, Some(not_started))]),
    ] {
        let task_properties = RecordingTaskPropertiesPort::default();
        let service = DocumentServiceImpl::new(
            make_mock_repo(),
            test_cloudfront_config(),
            sync_service_client::SyncServiceClient::new(
                "test-sync-key".to_string(),
                "http://sync-service.test".to_string(),
            ),
            TestUploadUrlPort,
            task_properties.clone(),
            TestConnectionService::default(),
            TestEntityAccessManagementService::default(),
            TestForeignEntityService::default(),
            TestEventBroker::default(),
        );

        crate::domain::ports::DocumentService::handle_task_properties(
            &service,
            &principal,
            "task-1",
            &CreateTaskRequest {
                task_name: "Intro to tasks".to_string(),
                markdown: None,
                project_id: None,
                team_id: None,
                property_values: None,
                share_with_team: false,
            },
        )
        .await
        .unwrap();

        let writes = task_properties.writes.lock().unwrap().clone();
        assert!(
            writes
                .iter()
                .all(|(written_as, _, _)| *written_as == principal)
        );
        assert_eq!(
            writes
                .into_iter()
                .map(|(_, property, value)| (property, value))
                .collect::<Vec<_>>(),
            expected
        );
    }
}

#[tokio::test]
async fn create_document_reuse_skips_content_url_and_created_event() {
    let mut repo = make_mock_repo();
    repo.expect_get_owner_team()
        .returning(|_| Box::pin(std::future::ready(Ok(None))));
    let created_metadata = make_test_metadata();
    repo.expect_import_email_attachment_document()
        .returning(move |_, _| {
            Box::pin(std::future::ready(Ok(EmailImportRepoOutcome::Reused(
                created_metadata.clone(),
            ))))
        });
    repo.expect_set_document_content().times(0);
    repo.expect_get_persisted_document_content()
        .return_once(|_| {
            Box::pin(std::future::ready(Ok(Some(DocumentContent::ready(
                DocumentContentLocation::ObjectStorage,
            )))))
        });
    repo.expect_get_team_task_metadata()
        .returning(|_| Box::pin(std::future::ready(Ok(None))));

    let (service, event_broker) = make_test_service_with_event_broker(repo);
    let args = ImportEmailAttachmentRepoArgs {
        email_attachment_id: uuid::Uuid::from_u128(9),
        owner: test_user(),
        document: new_document(FileType::Txt),
    };

    let response = crate::domain::ports::DocumentService::import_email_attachment(&service, args)
        .await
        .unwrap();

    assert!(response.document_response.presigned_url.is_none());
    assert_eq!(
        response
            .document_response
            .document_metadata
            .metadata
            .document_id,
        "doc-1"
    );
    assert_eq!(
        response.document_response.document_metadata.content,
        DocumentContent::ready(DocumentContentLocation::ObjectStorage),
    );
    assert!(event_broker.published().lock().unwrap().is_empty());
}

/// Imports an attachment that reuses `metadata`, whose content is `content`,
/// and returns the response with the uploads it signed.
async fn reimport_email_document(
    metadata: DocumentMetadata,
    content: DocumentContent,
    file_type: FileType,
) -> (CreateDocumentResponseData, Vec<(String, String)>) {
    let mut repo = make_mock_repo();
    repo.expect_get_owner_team()
        .returning(|_| Box::pin(std::future::ready(Ok(None))));
    repo.expect_import_email_attachment_document()
        .returning(move |_, _| {
            Box::pin(std::future::ready(Ok(EmailImportRepoOutcome::Reused(
                metadata.clone(),
            ))))
        });
    repo.expect_set_document_content().times(0);
    repo.expect_get_persisted_document_content()
        .return_once(|_| Box::pin(std::future::ready(Ok(Some(content)))));
    repo.expect_get_team_task_metadata()
        .returning(|_| Box::pin(std::future::ready(Ok(None))));
    let uploads = RecordingUploadUrlPort::default();
    let service = DocumentServiceImpl::new(
        repo,
        test_cloudfront_config(),
        sync_service_client::SyncServiceClient::new(
            "test-sync-key".to_string(),
            "http://sync-service.test".to_string(),
        ),
        uploads.clone(),
        TestTaskPropertiesPort,
        TestConnectionService::default(),
        TestEntityAccessManagementService::default(),
        TestForeignEntityService::default(),
        TestEventBroker::default(),
    );
    let args = ImportEmailAttachmentRepoArgs {
        email_attachment_id: uuid::Uuid::from_u128(9),
        owner: test_user(),
        document: new_document(file_type),
    };
    let response = crate::domain::ports::DocumentService::import_email_attachment(&service, args)
        .await
        .unwrap();
    let signed = uploads.uploads.lock().unwrap().clone();
    (response, signed)
}

fn pending_email_document(file_type: &str, sha: &str) -> (DocumentMetadata, DocumentContent) {
    let mut metadata = make_test_metadata();
    metadata.file_type = Some(file_type.to_string());
    metadata.sha = Some(sha.to_string());
    (
        metadata,
        DocumentContent::pending_at(DocumentContentLocation::ObjectStorage),
    )
}

#[tokio::test]
async fn reusing_a_pending_email_document_signs_its_upload_again() {
    let (metadata, content) = pending_email_document("pdf", "sha");
    let key = build_cloud_storage_bucket_document_key(&metadata.owner, "doc-1", 1);
    // The attachment's own declared type must not change the signed content type.
    let (response, signed) = reimport_email_document(metadata, content, FileType::Txt).await;

    assert!(response.document_response.presigned_url.is_some());
    assert_eq!(response.content_type, "application/pdf");
    assert_eq!(response.file_type.as_deref(), Some("pdf"));
    assert_eq!(signed, [(key, "sha".to_string())]);
}

#[tokio::test]
async fn different_bytes_cannot_replace_a_pending_email_document() {
    let (metadata, content) = pending_email_document("pdf", "other-sha");
    let (response, signed) = reimport_email_document(metadata, content, FileType::Pdf).await;

    assert!(response.document_response.presigned_url.is_none());
    assert!(signed.is_empty());
}

#[tokio::test]
async fn reusing_a_converting_docx_does_not_sign_an_upload() {
    let (metadata, _) = pending_email_document("docx", "sha");
    let (response, signed) = reimport_email_document(
        metadata,
        DocumentContent::pending_at(DocumentContentLocation::ConvertedPdf),
        FileType::Docx,
    )
    .await;

    assert!(response.document_response.presigned_url.is_none());
    assert!(signed.is_empty());
}

#[tokio::test]
async fn edited_interaction_bumps_document_before_publishing() {
    let mut repo = make_mock_repo();
    repo.expect_update_document_modified()
        .withf(|document_id| document_id == "doc-1")
        .times(1)
        .returning(|_| Box::pin(std::future::ready(Ok(()))));

    let (service, event_broker) = make_test_service_with_event_broker(repo);

    service
        .record_interaction("doc-1", InteractionReason::Edited)
        .await
        .unwrap();

    let published = event_broker.published();
    let published = published.lock().unwrap();
    assert_eq!(published.len(), 1);
    assert_eq!(published[0].topic, "macro.documents");
    assert_eq!(published[0].key, "doc-1");
    assert_eq!(published[0].payload["event_type"], "document.interaction");
    assert_eq!(published[0].payload["metadata"]["document_id"], "doc-1");
    assert_eq!(published[0].payload["metadata"]["reason"], "edited");
}

#[tokio::test]
async fn edited_interaction_does_not_publish_when_document_bump_fails() {
    let mut repo = make_mock_repo();
    repo.expect_update_document_modified()
        .withf(|document_id| document_id == "doc-1")
        .times(1)
        .returning(|_| Box::pin(std::future::ready(Err(anyhow!("db is down")))));

    let (service, event_broker) = make_test_service_with_event_broker(repo);

    let result = service
        .record_interaction("doc-1", InteractionReason::Edited)
        .await;

    assert_eq!(result.unwrap_err().to_string(), "db is down");
    assert!(event_broker.published().lock().unwrap().is_empty());
}

#[tokio::test]
async fn join_and_leave_interactions_publish_without_bumping_document() {
    for (reason, expected_reason) in [
        (InteractionReason::FirstJoin, "first_join"),
        (InteractionReason::LastLeave, "last_leave"),
    ] {
        let mut repo = make_mock_repo();
        repo.expect_update_document_modified().times(0);

        let (service, event_broker) = make_test_service_with_event_broker(repo);

        service.record_interaction("doc-1", reason).await.unwrap();

        let published = event_broker.published();
        let published = published.lock().unwrap();
        assert_eq!(published.len(), 1);
        assert_eq!(published[0].payload["event_type"], "document.interaction");
        assert_eq!(published[0].payload["metadata"]["reason"], expected_reason);
    }
}

fn spreadsheet_test_service(
    repo: MockDocumentRepo,
    sync: crate::domain::ports::sync::MockDocumentSyncPort,
) -> DocumentServiceImpl<
    MockDocumentRepo,
    TestUploadUrlPort,
    TestTaskPropertiesPort,
    TestConnectionService,
    TestEntityAccessManagementService,
    TestForeignEntityService,
    TestEventBroker,
    crate::domain::ports::sync::MockDocumentSyncPort,
> {
    DocumentServiceImpl::new(
        repo,
        test_cloudfront_config(),
        sync,
        TestUploadUrlPort,
        TestTaskPropertiesPort,
        TestConnectionService::default(),
        TestEntityAccessManagementService::default(),
        TestForeignEntityService::default(),
        TestEventBroker::default(),
    )
}

#[tokio::test]
async fn canvas_copy_preserves_live_content_and_legacy_canvases_still_copy() {
    for (shared, native) in [(false, false), (true, false), (true, true)] {
        let mut repo = make_mock_repo();
        repo.expect_get_persisted_document_content()
            .returning(move |_| {
                Box::pin(std::future::ready(Ok(Some(DocumentContent::ready(
                    if native {
                        DocumentContentLocation::SyncService
                    } else {
                        DocumentContentLocation::ObjectStorage
                    },
                )))))
            });
        let mut original = make_test_metadata();
        original.project_id = None;
        original.file_type = Some("canvas".to_string());
        repo.expect_get_document_metadata()
            .returning(move |_| Box::pin(std::future::ready(Ok(original.clone()))));
        let mut copied = make_test_metadata();
        copied.document_id = "doc-2".to_string();
        copied.project_id = None;
        copied.file_type = Some("canvas".to_string());
        repo.expect_copy_document()
            .returning(move |_, _| Box::pin(std::future::ready(Ok(copied.clone()))));
        repo.expect_get_owner_team()
            .returning(|_| Box::pin(std::future::ready(Ok(None))));
        repo.expect_get_latest_document_version_id()
            .times(usize::from(!native))
            .returning(|_| Box::pin(std::future::ready(Ok((1, true)))));
        repo.expect_set_document_content()
            .returning(|_, _| Box::pin(std::future::ready(Ok(()))));
        repo.expect_get_team_task_metadata()
            .returning(|_| Box::pin(std::future::ready(Ok(None))));
        let mut sync = crate::domain::ports::sync::MockDocumentSyncPort::new();
        sync.expect_exists()
            .withf(|id| id == "doc-1")
            .times(usize::from(!native))
            .returning(move |_| Box::pin(std::future::ready(Ok(shared))));
        sync.expect_copy_document()
            .withf(|from, to, _| from == "doc-1" && to == "doc-2")
            .times(usize::from(shared))
            .returning(|_, _, _| Box::pin(std::future::ready(Ok(()))));
        let service = spreadsheet_test_service(repo, sync);
        let mut context = task_document_context("doc-1");
        context.file_type = Some("canvas".to_string());
        context.sub_type = None;
        service
            .copy_document(
                authenticated_receipt("doc-1"),
                context,
                &CreationPrincipal::User(test_user()),
                "copied canvas".to_string(),
                None,
                None,
            )
            .await
            .unwrap();
    }
}

#[tokio::test]
async fn canvas_copy_failure_compensates_only_its_destinations_and_still_removes_rows() {
    for phase in ["lookup", "copy", "ready", "legacy-ready", "metadata"] {
        let mut repo = make_mock_repo();
        repo.expect_get_persisted_document_content().returning(|_| {
            Box::pin(std::future::ready(Ok(Some(DocumentContent::ready(
                DocumentContentLocation::ObjectStorage,
            )))))
        });
        let mut original = make_test_metadata();
        original.project_id = None;
        original.file_type = Some("canvas".to_string());
        repo.expect_get_document_metadata()
            .returning(move |_| Box::pin(std::future::ready(Ok(original.clone()))));
        let mut copied = make_test_metadata();
        copied.document_id = "doc-2".to_string();
        copied.project_id = None;
        copied.file_type = Some("canvas".to_string());
        repo.expect_copy_document()
            .returning(move |_, _| Box::pin(std::future::ready(Ok(copied.clone()))));
        repo.expect_get_owner_team()
            .returning(|_| Box::pin(std::future::ready(Ok(None))));
        repo.expect_get_latest_document_version_id()
            .returning(|_| Box::pin(std::future::ready(Ok((1, true)))));
        repo.expect_delete_document_by_id()
            .withf(|id| id == "doc-2")
            .times(1)
            .returning(|_| Box::pin(std::future::ready(Ok(()))));
        if phase.ends_with("ready") || phase == "metadata" {
            repo.expect_set_document_content()
                .times(1)
                .returning(move |_, _| {
                    Box::pin(std::future::ready(if phase == "metadata" {
                        Ok(())
                    } else {
                        Err(anyhow!("content update unavailable"))
                    }))
                });
        }
        if phase == "metadata" {
            repo.expect_get_team_task_metadata()
                .times(1)
                .returning(|_| Box::pin(std::future::ready(Err(anyhow!("metadata unavailable")))));
        }
        let mut sync = crate::domain::ports::sync::MockDocumentSyncPort::new();
        sync.expect_exists()
            .withf(|id| id == "doc-1")
            .times(1)
            .returning(move |_| {
                Box::pin(std::future::ready(if phase == "lookup" {
                    Err(anyhow!("lookup unavailable"))
                } else {
                    Ok(phase != "legacy-ready")
                }))
            });
        let room_attempted = phase == "copy" || phase == "ready" || phase == "metadata";
        sync.expect_copy_document()
            .withf(|from, to, _| from == "doc-1" && to == "doc-2")
            .times(usize::from(room_attempted))
            .returning(move |_, _, _| {
                Box::pin(std::future::ready(if phase == "copy" {
                    Err(anyhow!("room copy unavailable"))
                } else {
                    Ok(())
                }))
            });
        sync.expect_delete_document()
            .withf(|id| id == "doc-2")
            .times(usize::from(room_attempted))
            .returning(move |_| {
                Box::pin(std::future::ready(if phase == "copy" {
                    Err(anyhow!("room cleanup unavailable"))
                } else {
                    Ok(())
                }))
            });
        // Cleanup failures must not prevent the remaining compensation steps.
        let uploads = RecordingUploadUrlPort {
            fail_delete: phase == "copy",
            ..Default::default()
        };
        let deleted = uploads.deletions.clone();
        let service = DocumentServiceImpl::new(
            repo,
            test_cloudfront_config(),
            sync,
            uploads,
            TestTaskPropertiesPort,
            TestConnectionService::default(),
            TestEntityAccessManagementService::default(),
            TestForeignEntityService::default(),
            TestEventBroker::default(),
        );
        let mut context = task_document_context("doc-1");
        context.file_type = Some("canvas".to_string());
        context.sub_type = None;
        assert!(
            service
                .copy_document(
                    authenticated_receipt("doc-1"),
                    context,
                    &CreationPrincipal::User(test_user()),
                    "copied canvas".to_string(),
                    None,
                    None,
                )
                .await
                .is_err()
        );
        assert_eq!(
            *deleted.lock().unwrap(),
            vec!["macro|[email protected]/doc-2/1"]
        );
    }
}

fn spreadsheet_document() -> NewDocument {
    let mut document = new_document(FileType::Spreadsheet);
    document.sha = "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855".to_string();
    document
}

#[tokio::test]
async fn spreadsheet_creation_is_ready_only_after_sync_initialization() {
    let mut repo = make_mock_repo();
    let mut sync = crate::domain::ports::sync::MockDocumentSyncPort::new();
    let mut sequence = mockall::Sequence::new();
    repo.expect_get_owner_team()
        .returning(|_| Box::pin(std::future::ready(Ok(None))));
    repo.expect_create_document().returning(|_, _| {
        let mut metadata = make_test_metadata();
        metadata.file_type = Some("spreadsheet".to_string());
        Box::pin(std::future::ready(Ok(metadata)))
    });
    repo.expect_set_document_content()
        .withf(|_, content| {
            *content == DocumentContent::pending_at(DocumentContentLocation::SyncService)
        })
        .times(1)
        .in_sequence(&mut sequence)
        .returning(|_, _| Box::pin(std::future::ready(Ok(()))));
    sync.expect_initialize_spreadsheet()
        .withf(|id| id == "doc-1")
        .times(1)
        .in_sequence(&mut sequence)
        .returning(|_| Box::pin(std::future::ready(Ok(()))));
    repo.expect_set_document_content()
        .withf(|_, content| {
            *content == DocumentContent::ready(DocumentContentLocation::SyncService)
        })
        .times(1)
        .in_sequence(&mut sequence)
        .returning(|_, _| Box::pin(std::future::ready(Ok(()))));
    repo.expect_get_team_task_metadata()
        .returning(|_| Box::pin(std::future::ready(Ok(None))));
    let service = spreadsheet_test_service(repo, sync);
    let result = DocumentService::create_document(
        &service,
        &CreationPrincipal::User(test_user()),
        spreadsheet_document(),
        None,
    )
    .await
    .unwrap();
    assert!(result.document_response.presigned_url.is_none());
    assert_eq!(
        result.document_response.document_metadata.content,
        DocumentContent::ready(DocumentContentLocation::SyncService)
    );
}

#[tokio::test]
async fn failed_spreadsheet_initialization_cleans_up_document_metadata() {
    let mut repo = make_mock_repo();
    let mut sync = crate::domain::ports::sync::MockDocumentSyncPort::new();
    repo.expect_get_owner_team()
        .returning(|_| Box::pin(std::future::ready(Ok(None))));
    repo.expect_create_document()
        .returning(|_, _| Box::pin(std::future::ready(Ok(make_test_metadata()))));
    repo.expect_set_document_content()
        .withf(|_, content| content.state == DocumentContentState::Pending)
        .times(1)
        .returning(|_, _| Box::pin(std::future::ready(Ok(()))));
    sync.expect_initialize_spreadsheet()
        .times(1)
        .returning(|_| Box::pin(std::future::ready(Err(anyhow!("sync unavailable")))));
    repo.expect_delete_document_by_id()
        .withf(|id| id == "doc-1")
        .times(1)
        .returning(|_| Box::pin(std::future::ready(Ok(()))));
    let service = spreadsheet_test_service(repo, sync);
    assert!(
        DocumentService::create_document(
            &service,
            &CreationPrincipal::User(test_user()),
            spreadsheet_document(),
            None,
        )
        .await
        .is_err()
    );
}

#[tokio::test]
async fn native_spreadsheet_location_uses_sync_without_an_object_url() {
    let mut repo = make_mock_repo();
    repo.expect_get_persisted_document_content().returning(|_| {
        Box::pin(std::future::ready(Ok(Some(DocumentContent::ready(
            DocumentContentLocation::SyncService,
        )))))
    });
    let sync = crate::domain::ports::sync::MockDocumentSyncPort::new();
    let service = spreadsheet_test_service(repo, sync);
    let mut context = task_document_context("doc-1");
    context.file_type = Some("spreadsheet".to_string());
    context.sub_type = None;
    let result = service
        .get_document_location(
            &context,
            authenticated_receipt("doc-1"),
            LocationQueryParams {
                document_version_id: None,
                get_converted_docx_url: None,
            },
        )
        .await
        .unwrap();
    assert!(matches!(
        result,
        LocationResponseV3::SyncServiceContent { .. }
    ));
}

#[test]
fn spreadsheet_uploads_are_rejected_instead_of_discarding_their_bytes() {
    assert!(
        validate_spreadsheet_creation(Some(FileType::Spreadsheet), "uploaded-workbook-sha")
            .is_err()
    );
    assert!(
        validate_spreadsheet_creation(Some(FileType::Spreadsheet), &spreadsheet_document().sha)
            .is_ok()
    );
    assert!(validate_spreadsheet_creation(Some(FileType::Csv), "uploaded-csv-sha").is_ok());
}

#[test]
fn presigned_url_path_percent_encodes_the_owner_segment_of_the_object_key() {
    let service = make_test_service(make_mock_repo());
    let owner = Owner::from_principal_str("macro|[email protected]").unwrap();
    let key = build_cloud_storage_bucket_document_key(&owner, "doc-1", 7);

    // The object key stays the raw principal; only the URL path is encoded.
    assert_eq!(key, "macro|[email protected]/doc-1/7");
    assert_eq!(
        service.cloudfront_url_for_key(&key),
        "https://cdn.example.test/macro%7Cowner%40user.com/doc-1/7"
    );
}

#[test]
fn presigned_url_path_for_a_converted_docx_matches_the_legacy_encoding() {
    let service = make_test_service(make_mock_repo());
    let owner = Owner::from_principal_str("macro|[email protected]").unwrap();
    let key = build_docx_to_pdf_converted_document_key(&owner, "doc-1");

    assert_eq!(
        service.cloudfront_url_for_key(&key),
        "https://cdn.example.test/macro%7Cowner%40user.com/doc-1/converted.pdf"
    );
}

#[test]
fn presigned_url_path_for_bot_and_team_owners_uses_their_principals() {
    let service = make_test_service(make_mock_repo());
    let bot = Owner::from_principal_str("bot|00000000-0000-0000-0000-00000000a1a1").unwrap();
    let team = Owner::from_principal_str("00000000-0000-0000-0000-000000000456").unwrap();

    assert_eq!(
        service.cloudfront_url_for_key(&build_cloud_storage_bucket_document_key(&bot, "doc-1", 7)),
        "https://cdn.example.test/bot%7C00000000-0000-0000-0000-00000000a1a1/doc-1/7"
    );
    assert_eq!(
        service.cloudfront_url_for_key(&build_cloud_storage_bucket_document_key(&team, "doc-1", 7)),
        "https://cdn.example.test/00000000-0000-0000-0000-000000000456/doc-1/7"
    );
}

/// A random (v4) id: the kind a collab surface could also hold.
fn random_id(seed: u128) -> uuid::Uuid {
    uuid::Builder::from_random_bytes(seed.to_be_bytes()).into_uuid()
}

fn sync_with_session(
    id: uuid::Uuid,
    exists: bool,
) -> crate::domain::ports::sync::MockDocumentSyncPort {
    let mut sync = crate::domain::ports::sync::MockDocumentSyncPort::new();
    sync.expect_exists()
        .withf(move |document_id| document_id == id.to_string())
        .times(1)
        .returning(move |_| Box::pin(std::future::ready(Ok(exists))));
    sync
}

#[tokio::test]
async fn a_caller_chosen_id_that_already_has_a_session_is_refused() {
    let id = random_id(42);
    let mut repo = make_mock_repo();
    repo.expect_get_owner_team().times(0);
    repo.expect_create_document().times(0);
    let service = spreadsheet_test_service(repo, sync_with_session(id, true));
    let mut document = new_document(FileType::Md);
    document.id = Some(id);

    let err = DocumentService::create_document(
        &service,
        &CreationPrincipal::User(test_user()),
        document,
        None,
    )
    .await
    .unwrap_err();

    assert!(matches!(err, DocumentError::Conflict(_)));
}

#[tokio::test]
async fn a_caller_chosen_id_without_a_session_is_created() {
    let id = random_id(43);
    let mut repo = make_mock_repo();
    repo.expect_get_owner_team()
        .returning(|_| Box::pin(std::future::ready(Ok(None))));
    repo.expect_create_document()
        .withf(move |args, _| args.document.id == Some(id))
        .times(1)
        .returning(|_, _| {
            let mut metadata = make_test_metadata();
            metadata.file_type = Some("spreadsheet".to_string());
            Box::pin(std::future::ready(Ok(metadata)))
        });
    repo.expect_set_document_content()
        .returning(|_, _| Box::pin(std::future::ready(Ok(()))));
    repo.expect_get_team_task_metadata()
        .returning(|_| Box::pin(std::future::ready(Ok(None))));
    let mut sync = sync_with_session(id, false);
    sync.expect_initialize_spreadsheet()
        .times(1)
        .returning(|_| Box::pin(std::future::ready(Ok(()))));
    let service = spreadsheet_test_service(repo, sync);
    let mut document = spreadsheet_document();
    document.id = Some(id);

    DocumentService::create_document(
        &service,
        &CreationPrincipal::User(test_user()),
        document,
        None,
    )
    .await
    .unwrap();
}

#[tokio::test]
async fn a_deterministic_id_with_a_leftover_session_is_created() {
    // Starter documents use v5 ids, which no collab surface can have, so a
    // retry after a partial create that left a session still creates them.
    let id = uuid::Uuid::new_v5(&uuid::Uuid::NAMESPACE_OID, b"starter-document");
    let mut repo = make_mock_repo();
    repo.expect_get_owner_team()
        .returning(|_| Box::pin(std::future::ready(Ok(None))));
    repo.expect_create_document()
        .withf(move |args, _| args.document.id == Some(id))
        .times(1)
        .returning(|_, _| {
            let mut metadata = make_test_metadata();
            metadata.file_type = Some("spreadsheet".to_string());
            Box::pin(std::future::ready(Ok(metadata)))
        });
    repo.expect_set_document_content()
        .returning(|_, _| Box::pin(std::future::ready(Ok(()))));
    repo.expect_get_team_task_metadata()
        .returning(|_| Box::pin(std::future::ready(Ok(None))));
    let mut sync = crate::domain::ports::sync::MockDocumentSyncPort::new();
    sync.expect_exists().times(0);
    sync.expect_initialize_spreadsheet()
        .times(1)
        .returning(|_| Box::pin(std::future::ready(Ok(()))));
    let service = spreadsheet_test_service(repo, sync);
    let mut document = spreadsheet_document();
    document.id = Some(id);

    DocumentService::create_document(
        &service,
        &CreationPrincipal::User(test_user()),
        document,
        None,
    )
    .await
    .unwrap();
}

#[tokio::test]
async fn an_email_import_cannot_choose_its_document_id() {
    let mut repo = make_mock_repo();
    repo.expect_get_owner_team().times(0);
    repo.expect_import_email_attachment_document().times(0);
    let mut sync = crate::domain::ports::sync::MockDocumentSyncPort::new();
    sync.expect_exists().times(0);
    let service = spreadsheet_test_service(repo, sync);
    let mut document = new_document(FileType::Pdf);
    document.id = Some(random_id(44));

    let err = DocumentService::import_email_attachment(
        &service,
        ImportEmailAttachmentRepoArgs {
            email_attachment_id: uuid::Uuid::from_u128(45),
            owner: test_user(),
            document,
        },
    )
    .await
    .unwrap_err();

    assert!(matches!(err, DocumentError::BadRequest(_)));
}

#[tokio::test]
async fn user_display_names_join_the_parts_a_user_set() {
    for (first, last, expected) in [
        (Some(" Jacob "), Some("Beckerman"), Some("Jacob Beckerman")),
        (Some("Jacob"), None, Some("Jacob")),
        (Some(" "), None, None),
        (None, None, None),
    ] {
        let mut repo = make_mock_repo();
        repo.expect_get_user_name()
            .withf(|user_id| user_id == "macro|[email protected]")
            .return_once(move |_| {
                Box::pin(std::future::ready(Ok((
                    first.map(str::to_owned),
                    last.map(str::to_owned),
                ))))
            });
        let name = make_test_service(repo)
            .internal_get_user_display_name("macro|[email protected]")
            .await
            .unwrap();
        assert_eq!(name.as_deref(), expected);
    }
}

#[tokio::test]
async fn github_pull_request_tasks_are_returned_only_for_visible_pull_requests() {
    let visible_task = "00000000-0000-0000-0000-000000000201";
    let other_task = "00000000-0000-0000-0000-000000000202";
    let hidden_task = "00000000-0000-0000-0000-000000000203";
    let short = |id: &str| short_id_for_entity_id(id).unwrap();
    let links = vec![
        ("macro/repo/pull/1".to_string(), short(visible_task)),
        ("macro/repo/pull/1".to_string(), short(other_task)),
        ("macro/repo/pull/2".to_string(), short(hidden_task)),
        (
            "macro/repo/pull/1".to_string(),
            "not base58 0OIl".to_string(),
        ),
    ];
    let mut repo = make_mock_repo();
    repo.expect_get_github_pull_request_task_links()
        .withf(|keys| {
            keys == [
                "macro/repo/pull/1".to_string(),
                "macro/repo/pull/2".to_string(),
                "macro/repo/pull/3".to_string(),
            ]
        })
        .return_once(move |_| Box::pin(std::future::ready(Ok(links))));
    expect_authenticated_team_lookup(&mut repo, Vec::new());

    let service = make_test_service_with_foreign_entities(
        repo,
        vec![
            make_foreign_entity(
                uuid::uuid!("00000000-0000-0000-0000-000000000211"),
                "macro/repo/pull/1",
                GITHUB_PULL_REQUEST_FOREIGN_ENTITY_SOURCE,
                "macro|[email protected]",
                "user",
            ),
            make_foreign_entity(
                uuid::uuid!("00000000-0000-0000-0000-000000000212"),
                "macro/repo/pull/2",
                GITHUB_PULL_REQUEST_FOREIGN_ENTITY_SOURCE,
                "macro|[email protected]",
                "user",
            ),
        ],
    );

    let response = service
        .get_github_pull_request_tasks(
            "macro|[email protected]",
            vec![
                "macro/repo/pull/3".to_string(),
                "macro/repo/pull/1".to_string(),
                "macro/repo/pull/2".to_string(),
            ],
        )
        .await
        .unwrap();

    assert_eq!(
        response
            .pull_requests
            .iter()
            .map(|pull_request| (
                pull_request.github_key.as_str(),
                pull_request.task_ids.clone()
            ))
            .collect::<Vec<_>>(),
        vec![
            ("macro/repo/pull/3", vec![]),
            (
                "macro/repo/pull/1",
                vec![visible_task.to_string(), other_task.to_string()]
            ),
            ("macro/repo/pull/2", vec![]),
        ]
    );
}

#[tokio::test]
async fn github_pull_request_tasks_reject_oversized_lookups() {
    let service = make_test_service(make_mock_repo());
    let keys = (1..=101)
        .map(|number| format!("macro/repo/pull/{number}"))
        .collect();

    let result = service
        .get_github_pull_request_tasks("macro|[email protected]", keys)
        .await;

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

#[tokio::test]
async fn task_identity_names_a_team_task_by_its_team_number() {
    let document_id = "00000000-0000-0000-0000-000000000301";
    let mut repo = make_mock_repo();
    repo.expect_get_team_task_number()
        .withf(move |id| id == document_id)
        .return_once(|_| {
            Box::pin(std::future::ready(Ok(Some(TeamTaskNumber {
                team_slug: "ENG".to_string(),
                task_num: 42,
            }))))
        });
    let service = make_test_service(repo);

    let identity = service
        .get_task_identity(
            authenticated_receipt(document_id),
            &task_document_context(document_id),
        )
        .await
        .unwrap();

    assert_eq!(
        identity,
        TaskIdentity {
            document_id: document_id.to_string(),
            title: "Test task".to_string(),
            short_id: short_id_for_entity_id(document_id).unwrap(),
            team_task: Some(TeamTaskNumber {
                team_slug: "ENG".to_string(),
                task_num: 42,
            }),
        }
    );
}

#[tokio::test]
async fn task_identity_rejects_a_document_that_is_not_a_task() {
    let document_id = "00000000-0000-0000-0000-000000000302";
    let service = make_test_service(make_mock_repo());
    let mut document = task_document_context(document_id);
    document.sub_type = None;

    let result = service
        .get_task_identity(authenticated_receipt(document_id), &document)
        .await;

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

#[tokio::test]
async fn task_identity_treats_a_deleted_task_as_missing() {
    let document_id = "00000000-0000-0000-0000-000000000303";
    let service = make_test_service(make_mock_repo());
    let mut document = task_document_context(document_id);
    document.deleted_at = Some(chrono::Utc::now());

    let result = service
        .get_task_identity(authenticated_receipt(document_id), &document)
        .await;

    assert!(matches!(result, Err(DocumentError::NotFound(_))));
}

#[tokio::test]
async fn native_canvas_location_uses_sync_without_an_object_url() {
    let mut repo = make_mock_repo();
    repo.expect_get_persisted_document_content().returning(|_| {
        Box::pin(std::future::ready(Ok(Some(DocumentContent::ready(
            DocumentContentLocation::SyncService,
        )))))
    });
    let sync = crate::domain::ports::sync::MockDocumentSyncPort::new();
    let service = spreadsheet_test_service(repo, sync);
    let mut context = task_document_context("doc-1");
    context.file_type = Some("canvas".to_string());
    context.sub_type = None;
    let result = service
        .get_document_location(
            &context,
            authenticated_receipt("doc-1"),
            LocationQueryParams {
                document_version_id: None,
                get_converted_docx_url: None,
            },
        )
        .await
        .unwrap();
    assert!(matches!(
        result,
        LocationResponseV3::SyncServiceContent { .. }
    ));
}

#[tokio::test]
async fn a_document_with_its_own_dates_dates_its_folder_by_them() {
    let created_at = chrono::DateTime::parse_from_rfc3339("2021-03-01T00:00:00Z")
        .unwrap()
        .to_utc();
    let updated_at = chrono::DateTime::parse_from_rfc3339("2024-02-01T00:00:00Z")
        .unwrap()
        .to_utc();
    let mut repo = make_mock_repo();
    repo.expect_get_owner_team()
        .returning(|_| Box::pin(std::future::ready(Ok(None))));
    repo.expect_create_document().returning(|_, _| {
        let mut metadata = make_test_metadata();
        metadata.document_id = "00000000-0000-0000-0000-000000000001".to_string();
        Box::pin(std::future::ready(Ok(metadata)))
    });
    repo.expect_set_document_content()
        .returning(|_, _| Box::pin(std::future::ready(Ok(()))));
    repo.expect_get_team_task_metadata()
        .returning(|_| Box::pin(std::future::ready(Ok(None))));
    repo.expect_update_project_modified().times(0);
    repo.expect_extend_project_dates()
        .withf(move |project_id, created, updated| {
            project_id == "00000000-0000-0000-0000-000000000009"
                && *created == created_at
                && *updated == updated_at
        })
        .times(1)
        .returning(|_, _, _| Box::pin(std::future::ready(Ok(()))));
    let (service, _event_broker) = make_test_service_with_event_broker(repo);

    let mut document = new_document(FileType::Txt);
    document.project_id = Some(uuid::Uuid::from_u128(9));
    document.created_at = Some(created_at);
    document.updated_at = Some(updated_at);
    crate::domain::ports::DocumentService::create_document(
        &service,
        &CreationPrincipal::User(test_user()),
        document,
        None,
    )
    .await
    .unwrap();
}

#[tokio::test]
async fn a_document_without_dates_marks_its_folder_updated_now() {
    let mut repo = make_mock_repo();
    repo.expect_get_owner_team()
        .returning(|_| Box::pin(std::future::ready(Ok(None))));
    repo.expect_create_document().returning(|_, _| {
        let mut metadata = make_test_metadata();
        metadata.document_id = "00000000-0000-0000-0000-000000000001".to_string();
        Box::pin(std::future::ready(Ok(metadata)))
    });
    repo.expect_set_document_content()
        .returning(|_, _| Box::pin(std::future::ready(Ok(()))));
    repo.expect_get_team_task_metadata()
        .returning(|_| Box::pin(std::future::ready(Ok(None))));
    repo.expect_extend_project_dates().times(0);
    repo.expect_update_project_modified()
        .withf(|project_id| project_id == "00000000-0000-0000-0000-000000000009")
        .times(1)
        .returning(|_| Box::pin(std::future::ready(Ok(()))));
    let (service, _event_broker) = make_test_service_with_event_broker(repo);

    let mut document = new_document(FileType::Txt);
    document.project_id = Some(uuid::Uuid::from_u128(9));
    crate::domain::ports::DocumentService::create_document(
        &service,
        &CreationPrincipal::User(test_user()),
        document,
        None,
    )
    .await
    .unwrap();
}