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.

17.1 KB
Raw Blame
use super::*;
use std::sync::{Arc, Mutex};
use tokio::sync::Notify;

use bot_id::{BotId, NonSystemBotId};
use entity_access::domain::models::{BotReceiptScope, Entity, EntityPermission};
use macro_user_id::user_id::MacroUserIdStr;
use model::document::response::DocumentResponseMetadata;
use models_permissions::share_permission::access_level::AccessLevel;
use uuid::Uuid;

use crate::domain::{
    content::DocumentContent,
    models::{CreateTaskRequest, NewDocument},
    response::{CreateDocumentResponseData, DocumentResponse, DocumentResponseMetadataWithContent},
};

const DOCUMENT_ID: &str = "00000000-0000-0000-0000-000000000123";
const PROJECT_ID: &str = "00000000-0000-0000-0000-000000000456";
const TEAM_ID: Uuid = Uuid::from_u128(7);

fn owner() -> MacroUserIdStr<'static> {
    MacroUserIdStr::try_from("macro|[email protected]".to_string()).unwrap()
}

fn other_user() -> MacroUserIdStr<'static> {
    MacroUserIdStr::try_from("macro|[email protected]".to_string()).unwrap()
}

fn principal() -> CreationPrincipal {
    CreationPrincipal::BotForUser {
        bot: bot_id::MACRO_AI_BOT_ID,
        user: owner(),
    }
}

fn team_bot() -> CreationPrincipal {
    CreationPrincipal::TeamBot {
        bot: NonSystemBotId::new(BotId::TEST_A).unwrap(),
        team: TEAM_ID,
    }
}

#[derive(Default)]
struct Gate {
    entered: Notify,
    release: Notify,
}

impl Gate {
    async fn wait(&self) {
        self.entered.notify_one();
        self.release.notified().await;
    }
}

async fn wait_for(notification: &Notify) {
    tokio::time::timeout(Duration::from_secs(5), notification.notified())
        .await
        .expect("operation should make progress");
}

#[derive(Default)]
struct RecordingService {
    creates: Mutex<Vec<(CreationPrincipal, NewDocument)>>,
    cleanups: Mutex<Vec<String>>,
    omit_url: bool,
    create_gate: Option<Arc<Gate>>,
    cleanup_gate: Option<Arc<Gate>>,
    cleanup_finished: Notify,
}

impl DocumentCreationService for RecordingService {
    async fn create_document(
        &self,
        principal: &CreationPrincipal,
        document: NewDocument,
        _job_id: Option<String>,
    ) -> Result<CreateDocumentResponseData, DocumentError> {
        let file_type = document.file_type.map(|kind| kind.to_string());
        let document_name = document.document_name.clone();
        self.creates
            .lock()
            .unwrap()
            .push((principal.clone(), document));
        if let Some(gate) = &self.create_gate {
            gate.wait().await;
        }
        Ok(CreateDocumentResponseData {
            document_response: DocumentResponse {
                document_metadata: DocumentResponseMetadataWithContent::new(
                    DocumentResponseMetadata {
                        document_id: DOCUMENT_ID.to_string(),
                        document_version_id: 1,
                        owner: principal.owner(),
                        document_name,
                        file_type: file_type.clone(),
                        sha: None,
                        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,
                        sub_type: None,
                    },
                    DocumentContent::pending(),
                ),
                presigned_url: (!self.omit_url)
                    .then(|| "https://storage.example/upload".to_string()),
            },
            content_type: "application/octet-stream".to_string(),
            file_type,
        })
    }

    async fn initialize_canvas(&self, _document_id: &str) -> Result<(), DocumentError> {
        panic!("unexpected Canvas initialization")
    }

    async fn handle_task_properties(
        &self,
        _: &CreationPrincipal,
        _: &str,
        _: &CreateTaskRequest,
    ) -> Result<(), DocumentError> {
        panic!("file uploads do not create tasks")
    }

    async fn mark_document_uploaded(&self, _: &str) -> Result<(), DocumentError> {
        panic!("the storage event pipeline finalizes uploads")
    }

    async fn set_document_content(&self, _: &str, _: DocumentContent) -> Result<(), DocumentError> {
        panic!("the storage event pipeline finalizes uploads")
    }

    async fn cleanup_created_document(&self, id: &str) {
        if let Some(gate) = &self.cleanup_gate {
            gate.wait().await;
        }
        self.cleanups.lock().unwrap().push(id.to_string());
        self.cleanup_finished.notify_one();
    }
}

#[derive(Default)]
struct RecordingUploader {
    uploads: Mutex<Vec<DocumentBytesUpload>>,
    fail: bool,
    gate: Option<Arc<Gate>>,
    finished: Notify,
}

impl DocumentBytesUploadPort for Arc<RecordingUploader> {
    async fn upload_document_bytes(
        &self,
        upload: DocumentBytesUpload,
    ) -> Result<(), DocumentError> {
        self.uploads.lock().unwrap().push(upload);
        if let Some(gate) = &self.gate {
            gate.wait().await;
        }
        self.finished.notify_one();
        if self.fail {
            return Err(DocumentError::Gone);
        }
        Ok(())
    }
}

fn upload(name: &str, bytes: Vec<u8>) -> NewFileUpload {
    NewFileUpload {
        file_name: name.to_string(),
        bytes,
        project: None,
    }
}

fn project(entity_type: EntityType) -> Entity {
    Entity {
        entity_id: PROJECT_ID.to_string(),
        entity_type,
    }
}

fn edit() -> EntityPermission {
    EntityPermission::AccessLevel {
        access_level: AccessLevel::Edit,
    }
}

fn bot_receipt(
    bot: BotId,
    scope: BotReceiptScope,
    entity_type: EntityType,
) -> EntityAccessReceipt<EditAccessLevel> {
    EntityAccessReceipt::try_new_bot(bot.into(), scope, project(entity_type), edit()).unwrap()
}

fn project_receipt(
    user: MacroUserIdStr<'static>,
    entity_type: EntityType,
) -> EntityAccessReceipt<EditAccessLevel> {
    bot_receipt(
        bot_id::MACRO_AI_BOT_ID,
        BotReceiptScope::User { acting_user: user },
        entity_type,
    )
}

fn user_receipt(user: MacroUserIdStr<'static>) -> EntityAccessReceipt<EditAccessLevel> {
    EntityAccessReceipt::try_new_authenticated_user(user, project(EntityType::Project), edit())
        .unwrap()
}

#[tokio::test]
async fn uploads_exact_bytes_with_checksums_principal_and_project() {
    let service = Arc::new(RecordingService::default());
    let uploader = Arc::new(RecordingUploader::default());
    let creator = DocumentCreator::new(service.clone(), (), uploader.clone(), ());
    let bytes = vec![0, 255, 128, 13, 10];
    let mut file = upload("Report.PDF", bytes.clone());
    file.project = Some(project_receipt(owner(), EntityType::Project));
    let created = creator.upload_file(&principal(), file).await.unwrap();
    assert_eq!(created.document_id(), DOCUMENT_ID);
    assert_eq!(
        created
            .response()
            .document_response
            .document_metadata
            .content,
        DocumentContent::pending()
    );
    let creates = service.creates.lock().unwrap();
    assert_eq!(creates.len(), 1);
    let (created_for, document) = &creates[0];
    assert_eq!(*created_for, principal());
    assert_eq!(document.document_name, "Report");
    assert_eq!(document.file_type, Some(FileType::Pdf));
    assert_eq!(document.project_id, Some(PROJECT_ID.parse().unwrap()));
    assert_eq!(document.sha, file_shas(&bytes).hex);
    let uploads = uploader.uploads.lock().unwrap();
    assert_eq!(uploads.len(), 1);
    assert_eq!(uploads[0].bytes, bytes);
    assert_eq!(uploads[0].base64_sha256, file_shas(&bytes).base64);
    assert_eq!(uploads[0].content_type, "application/octet-stream");
    assert!(service.cleanups.lock().unwrap().is_empty());
}

#[tokio::test]
async fn preserves_unknown_extensions_and_leaves_conversion_to_the_pipeline() {
    for (name, expected_name, expected_type) in [
        ("archive.custom", "archive.custom", None),
        ("README", "README", None),
        ("report.docx", "report", Some(FileType::Docx)),
        ("notes.md", "notes", Some(FileType::Md)),
    ] {
        let service = Arc::new(RecordingService::default());
        let uploader = Arc::new(RecordingUploader::default());
        let creator = DocumentCreator::new(service.clone(), (), uploader.clone(), ());
        creator
            .upload_file(&principal(), upload(name, b"contents".to_vec()))
            .await
            .unwrap();
        let creates = service.creates.lock().unwrap();
        assert_eq!(creates[0].1.document_name, expected_name);
        assert_eq!(creates[0].1.file_type, expected_type);
    }
}

#[tokio::test]
async fn rejects_invalid_files_before_creating_metadata() {
    let service = Arc::new(RecordingService::default());
    let uploader = Arc::new(RecordingUploader::default());
    let creator = DocumentCreator::new(service.clone(), (), uploader.clone(), ());
    for file in [
        upload("../report.pdf", vec![]),
        upload("C:\\report.pdf", vec![]),
        upload(" ", vec![]),
        upload(".pdf", vec![]),
        upload("bad\0.pdf", vec![]),
        upload("native.spreadsheet", vec![]),
        upload("bad.md", vec![255]),
        upload("large.pdf", vec![0; MAX_INLINE_UPLOAD_BYTES + 1]),
    ] {
        assert!(matches!(
            creator.upload_file(&principal(), file).await,
            Err(DocumentError::BadRequest(_))
        ));
    }
    assert!(service.creates.lock().unwrap().is_empty());
    assert!(uploader.uploads.lock().unwrap().is_empty());
}

#[tokio::test]
async fn accepts_only_project_receipts_minted_for_the_uploading_principal() {
    let project_id: Uuid = PROJECT_ID.parse().unwrap();
    let team_receipt = || {
        bot_receipt(
            BotId::TEST_A,
            BotReceiptScope::Team { team_id: TEAM_ID },
            EntityType::Project,
        )
    };
    for (uploader_principal, receipt, accepted) in [
        (
            principal(),
            project_receipt(owner(), EntityType::Project),
            true,
        ),
        (
            CreationPrincipal::User(owner()),
            user_receipt(owner()),
            true,
        ),
        (team_bot(), team_receipt(), true),
        (
            principal(),
            project_receipt(other_user(), EntityType::Project),
            false,
        ),
        (
            principal(),
            project_receipt(owner(), EntityType::Document),
            false,
        ),
        (
            principal(),
            bot_receipt(
                BotId::TEST_A,
                BotReceiptScope::User {
                    acting_user: owner(),
                },
                EntityType::Project,
            ),
            false,
        ),
        (principal(), user_receipt(owner()), false),
        (
            CreationPrincipal::User(owner()),
            project_receipt(owner(), EntityType::Project),
            false,
        ),
        (
            CreationPrincipal::User(owner()),
            user_receipt(other_user()),
            false,
        ),
        (
            team_bot(),
            bot_receipt(
                BotId::TEST_A,
                BotReceiptScope::Team {
                    team_id: Uuid::from_u128(8),
                },
                EntityType::Project,
            ),
            false,
        ),
        (
            team_bot(),
            bot_receipt(
                BotId::TEST_B,
                BotReceiptScope::Team { team_id: TEAM_ID },
                EntityType::Project,
            ),
            false,
        ),
    ] {
        let service = Arc::new(RecordingService::default());
        let uploader = Arc::new(RecordingUploader::default());
        let creator = DocumentCreator::new(service.clone(), (), uploader.clone(), ());
        let mut file = upload("report.pdf", vec![]);
        file.project = Some(receipt);
        let result = creator.upload_file(&uploader_principal, file).await;
        let creates = service.creates.lock().unwrap();
        if accepted {
            result.unwrap();
            assert_eq!(creates.len(), 1);
            assert_eq!(creates[0].0, uploader_principal);
            assert_eq!(creates[0].1.project_id, Some(project_id));
        } else {
            assert!(matches!(result, Err(DocumentError::Unauthorized)));
            assert!(creates.is_empty());
            assert!(uploader.uploads.lock().unwrap().is_empty());
        }
    }
}

#[tokio::test]
async fn cleans_up_when_storage_upload_fails_or_url_is_missing() {
    for omit_url in [false, true] {
        let service = Arc::new(RecordingService {
            omit_url,
            ..Default::default()
        });
        let uploader = Arc::new(RecordingUploader {
            fail: true,
            ..Default::default()
        });
        let creator = DocumentCreator::new(service.clone(), (), uploader.clone(), ());
        assert!(
            creator
                .upload_file(&principal(), upload("report.pdf", vec![1]))
                .await
                .is_err()
        );
        assert_eq!(*service.cleanups.lock().unwrap(), [DOCUMENT_ID]);
        assert_eq!(
            uploader.uploads.lock().unwrap().len(),
            usize::from(!omit_url)
        );
    }
}

#[tokio::test]
async fn accepts_empty_files_and_the_exact_size_limit() {
    let service = Arc::new(RecordingService::default());
    let uploader = Arc::new(RecordingUploader::default());
    let creator = DocumentCreator::new(service, (), uploader.clone(), ());
    for size in [0, MAX_INLINE_UPLOAD_BYTES] {
        creator
            .upload_file(&principal(), upload("file.bin", vec![0; size]))
            .await
            .unwrap();
    }
    assert_eq!(uploader.uploads.lock().unwrap().len(), 2);
}

#[tokio::test]
async fn dropping_the_caller_during_metadata_creation_finishes_the_upload() {
    let gate = Arc::new(Gate::default());
    let service = Arc::new(RecordingService {
        create_gate: Some(gate.clone()),
        ..Default::default()
    });
    let uploader = Arc::new(RecordingUploader::default());
    let creator = DocumentCreator::new(service.clone(), (), uploader.clone(), ());
    let caller = tokio::spawn(async move {
        creator
            .upload_file(&principal(), upload("report.pdf", vec![1]))
            .await
    });

    wait_for(&gate.entered).await;
    caller.abort();
    assert!(caller.await.unwrap_err().is_cancelled());
    assert!(uploader.uploads.lock().unwrap().is_empty());
    gate.release.notify_one();

    wait_for(&uploader.finished).await;
    assert_eq!(uploader.uploads.lock().unwrap().len(), 1);
    assert!(service.cleanups.lock().unwrap().is_empty());
}

#[tokio::test]
async fn dropping_the_caller_during_upload_finishes_or_cleans_up() {
    for fail in [false, true] {
        let gate = Arc::new(Gate::default());
        let service = Arc::new(RecordingService::default());
        let uploader = Arc::new(RecordingUploader {
            fail,
            gate: Some(gate.clone()),
            ..Default::default()
        });
        let creator = DocumentCreator::new(service.clone(), (), uploader.clone(), ());
        let caller = tokio::spawn(async move {
            creator
                .upload_file(&principal(), upload("report.pdf", vec![1]))
                .await
        });

        wait_for(&gate.entered).await;
        caller.abort();
        assert!(caller.await.unwrap_err().is_cancelled());
        gate.release.notify_one();

        if fail {
            wait_for(&service.cleanup_finished).await;
            assert_eq!(*service.cleanups.lock().unwrap(), [DOCUMENT_ID]);
        } else {
            wait_for(&uploader.finished).await;
            assert!(service.cleanups.lock().unwrap().is_empty());
        }
    }
}

#[tokio::test]
async fn dropping_the_caller_during_cleanup_does_not_interrupt_cleanup() {
    let gate = Arc::new(Gate::default());
    let service = Arc::new(RecordingService {
        cleanup_gate: Some(gate.clone()),
        ..Default::default()
    });
    let uploader = Arc::new(RecordingUploader {
        fail: true,
        ..Default::default()
    });
    let creator = DocumentCreator::new(service.clone(), (), uploader, ());
    let caller = tokio::spawn(async move {
        creator
            .upload_file(&principal(), upload("report.pdf", vec![1]))
            .await
    });

    wait_for(&gate.entered).await;
    caller.abort();
    assert!(caller.await.unwrap_err().is_cancelled());
    gate.release.notify_one();

    wait_for(&service.cleanup_finished).await;
    assert_eq!(*service.cleanups.lock().unwrap(), [DOCUMENT_ID]);
}

#[tokio::test(start_paused = true)]
async fn storage_upload_timeout_cleans_up_metadata() {
    let service = Arc::new(RecordingService::default());
    let uploader = Arc::new(RecordingUploader {
        gate: Some(Arc::new(Gate::default())),
        ..Default::default()
    });
    let creator = DocumentCreator::new(service.clone(), (), uploader.clone(), ());
    let error = creator
        .upload_file(&principal(), upload("report.pdf", vec![1]))
        .await
        .unwrap_err();

    assert!(error.to_string().contains("file upload timed out"));
    assert_eq!(uploader.uploads.lock().unwrap().len(), 1);
    assert_eq!(*service.cleanups.lock().unwrap(), [DOCUMENT_ID]);
}