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.

10.9 KB
Raw Blame
use macro_event_broker::{Event, MacroEvent as _, TopicEvent};
use model::document::FileType;
use model_owner::Owner;
use serde_json::{Value, json};
use uuid::Uuid;

use super::{
    DocumentContentUploadedMetadata, DocumentCopiedMetadata, DocumentCreatedMetadata,
    DocumentInteractionMetadata, DocumentMacroEvent, DocumentPurgedMetadata,
    DocumentSyncContentUpdatedMetadata, DocumentTopicEvent, DocumentUpdatedMetadata,
    InteractionReason,
};

const DOCUMENT_ID: &str = "11111111-1111-1111-1111-111111111111";

fn owner() -> Owner {
    Owner::from_principal_str("macro|[email protected]").expect("valid owner")
}

fn assert_wire_round_trip(event: Event<DocumentTopicEvent>, expected: Value) {
    assert_eq!(
        serde_json::to_value(&event).expect("event serializes"),
        expected
    );

    let decoded: Event<DocumentTopicEvent> =
        serde_json::from_value(expected).expect("event deserializes");
    assert_eq!(decoded, event);
}

#[test]
fn owner_bearing_events_round_trip_all_owner_kinds_as_strings() {
    for principal in [
        "macro|[email protected]",
        "bot|00000000-0000-0000-0000-000000000001",
        "01998a30-1a2b-7c3d-9e4f-5a6b7c8d9e0f",
    ] {
        let owner = Owner::from_principal_str(principal).unwrap();
        let events = [
            DocumentTopicEvent::Created(DocumentCreatedMetadata {
                document_id: DOCUMENT_ID.to_string(),
                owner: owner.clone(),
                actor: None,
                on_behalf_of: None,
                document_name: "notes".to_string(),
                file_type: None,
                project_id: None,
                sub_type: None,
                created_at: None,
            }),
            DocumentTopicEvent::Updated(DocumentUpdatedMetadata {
                document_id: DOCUMENT_ID.to_string(),
                owner: owner.clone(),
                actor_user_id: None,
                actor: None,
                on_behalf_of: None,
                document_name: None,
                previous_project_id: None,
                project_id: None,
                file_type: None,
                share_permission_updated: false,
            }),
            DocumentTopicEvent::ContentUploaded(DocumentContentUploadedMetadata {
                document_id: DOCUMENT_ID.to_string(),
                owner: owner.clone(),
                file_type: FileType::Pdf,
                document_version_id: None,
            }),
            DocumentTopicEvent::Copied(DocumentCopiedMetadata {
                document_id: DOCUMENT_ID.to_string(),
                source_document_id: "source-document".to_string(),
                source_version_id: None,
                owner,
                actor: None,
                on_behalf_of: None,
                document_name: "copy".to_string(),
                file_type: None,
                project_id: None,
                sub_type: None,
            }),
        ];
        for event in events {
            let envelope = Event::with_event_id(Uuid::from_u128(1), event);
            let payload = serde_json::to_value(&envelope).unwrap();
            assert_eq!(payload["schema_version"], 1);
            assert_eq!(payload["metadata"]["owner"], principal);
            let decoded =
                DocumentMacroEvent::decode(DOCUMENT_ID, &serde_json::to_vec(&payload).unwrap())
                    .expect("all owner kinds decode through the broker");
            assert_eq!(decoded.event(), &envelope);
        }
    }
}

#[test]
fn content_uploaded_serializes_to_the_exact_envelope() {
    let event = Event::with_event_id(
        Uuid::from_u128(1),
        DocumentTopicEvent::ContentUploaded(DocumentContentUploadedMetadata {
            document_id: DOCUMENT_ID.to_string(),
            owner: owner(),
            file_type: FileType::Pdf,
            document_version_id: Some("convert".to_string()),
        }),
    );

    assert_wire_round_trip(
        event,
        json!({
            "event_id": "00000000-0000-0000-0000-000000000001",
            "schema_version": 1,
            "event_type": "document.content_uploaded",
            "metadata": {
                "document_id": DOCUMENT_ID,
                "owner": "macro|[email protected]",
                "file_type": "pdf",
                "document_version_id": "convert",
            },
        }),
    );
}

#[test]
fn sync_content_updated_serializes_to_the_exact_envelope() {
    let event = Event::with_event_id(
        Uuid::from_u128(2),
        DocumentTopicEvent::SyncContentUpdated(DocumentSyncContentUpdatedMetadata {
            editors: Vec::new(),
            document_id: DOCUMENT_ID.to_string(),
            file_type: FileType::Md,
            document_version_id: None,
            actor: None,
            on_behalf_of: None,
        }),
    );

    assert_wire_round_trip(
        event,
        json!({
            "event_id": "00000000-0000-0000-0000-000000000002",
            "schema_version": 1,
            "event_type": "document.sync_content_updated",
            "metadata": {
                "document_id": DOCUMENT_ID,
                "file_type": "md",
                "document_version_id": null,
            },
        }),
    );
}

#[test]
fn purged_serializes_to_the_exact_envelope() {
    let event = Event::with_event_id(
        Uuid::from_u128(3),
        DocumentTopicEvent::Purged(DocumentPurgedMetadata {
            document_id: DOCUMENT_ID.to_string(),
        }),
    );

    assert_wire_round_trip(
        event,
        json!({
            "event_id": "00000000-0000-0000-0000-000000000003",
            "schema_version": 1,
            "event_type": "document.purged",
            "metadata": {
                "document_id": DOCUMENT_ID,
            },
        }),
    );
}

#[test]
fn optional_document_versions_support_present_and_absent_values() {
    let events = [
        DocumentTopicEvent::ContentUploaded(DocumentContentUploadedMetadata {
            document_id: DOCUMENT_ID.to_string(),
            owner: owner(),
            file_type: FileType::Pdf,
            document_version_id: None,
        }),
        DocumentTopicEvent::SyncContentUpdated(DocumentSyncContentUpdatedMetadata {
            editors: Vec::new(),
            document_id: DOCUMENT_ID.to_string(),
            file_type: FileType::Md,
            document_version_id: Some("snapshot-7".to_string()),
            actor: None,
            on_behalf_of: None,
        }),
    ];

    let content_uploaded = serde_json::to_value(&events[0]).expect("event serializes");
    assert_eq!(
        content_uploaded["metadata"]["document_version_id"],
        Value::Null
    );

    let sync_content_updated = serde_json::to_value(&events[1]).expect("event serializes");
    assert_eq!(
        sync_content_updated["metadata"]["document_version_id"],
        "snapshot-7"
    );

    for event in events {
        let payload = serde_json::to_vec(&event).expect("event serializes");
        let decoded: DocumentTopicEvent =
            serde_json::from_slice(&payload).expect("event deserializes");
        assert_eq!(decoded, event);
    }
}

#[test]
fn search_event_constructors_use_the_document_key_and_schema_v1() {
    assert_eq!(<DocumentTopicEvent as TopicEvent>::SCHEMA_VERSION, 1);

    let content_metadata = DocumentContentUploadedMetadata {
        document_id: DOCUMENT_ID.to_string(),
        owner: owner(),
        file_type: FileType::Pdf,
        document_version_id: Some("version-1".to_string()),
    };
    let content_uploaded =
        DocumentMacroEvent::content_uploaded(DOCUMENT_ID, content_metadata.clone());
    assert_eq!(content_uploaded.key(), DOCUMENT_ID);
    assert_eq!(content_uploaded.event().schema_version, 1);
    assert_eq!(
        &content_uploaded.event().event,
        &DocumentTopicEvent::ContentUploaded(content_metadata)
    );

    let sync_metadata = DocumentSyncContentUpdatedMetadata {
        editors: Vec::new(),
        document_id: DOCUMENT_ID.to_string(),
        file_type: FileType::Md,
        document_version_id: None,
        actor: None,
        on_behalf_of: None,
    };
    let sync_content_updated =
        DocumentMacroEvent::sync_content_updated(DOCUMENT_ID, sync_metadata.clone());
    assert_eq!(sync_content_updated.key(), DOCUMENT_ID);
    assert_eq!(sync_content_updated.event().schema_version, 1);
    assert_eq!(
        &sync_content_updated.event().event,
        &DocumentTopicEvent::SyncContentUpdated(sync_metadata)
    );

    let purged_metadata = DocumentPurgedMetadata {
        document_id: DOCUMENT_ID.to_string(),
    };
    let purged = DocumentMacroEvent::purged(DOCUMENT_ID, purged_metadata.clone());
    assert_eq!(purged.key(), DOCUMENT_ID);
    assert_eq!(purged.event().schema_version, 1);
    assert_eq!(
        &purged.event().event,
        &DocumentTopicEvent::Purged(purged_metadata)
    );
}

#[test]
fn created_events_without_attribution_still_decode() {
    // Frozen pre-attribution v1 payload, not generated by the current serializer.
    let payload = include_bytes!("fixtures/document_created_v1.json");
    let decoded = DocumentMacroEvent::decode(DOCUMENT_ID, payload)
        .expect("pre-attribution created event decodes through the broker");
    assert_eq!(decoded.event().schema_version, 1);
    let expected: Value = serde_json::from_slice(payload).unwrap();
    assert_eq!(serde_json::to_value(decoded.event()).unwrap(), expected);

    match &decoded.event().event {
        DocumentTopicEvent::Created(metadata) => {
            assert_eq!(
                metadata.owner,
                Owner::from_principal_str("macro|[email protected]").unwrap()
            );
            assert_eq!(metadata.actor, None);
            assert_eq!(metadata.on_behalf_of, None);
        }
        other => panic!("expected created, got {other:?}"),
    }
}

#[test]
fn existing_v1_document_events_still_decode() {
    let payload = json!({
        "event_id": "00000000-0000-0000-0000-000000000004",
        "schema_version": 1,
        "event_type": "document.interaction",
        "metadata": {
            "document_id": DOCUMENT_ID,
            "reason": "edited",
        },
    });

    let decoded = DocumentMacroEvent::decode(
        DOCUMENT_ID,
        &serde_json::to_vec(&payload).expect("payload serializes"),
    )
    .expect("existing v1 event decodes");

    assert_eq!(decoded.key(), DOCUMENT_ID);
    assert_eq!(decoded.event().schema_version, 1);
    assert_eq!(decoded.event().event_id, Uuid::from_u128(4));
    assert_eq!(
        &decoded.event().event,
        &DocumentTopicEvent::Interaction(DocumentInteractionMetadata {
            document_id: DOCUMENT_ID.to_string(),
            reason: InteractionReason::Edited,
        })
    );
}

#[test]
fn sync_extract_drops_invalid_attribution_strings() {
    let metadata = DocumentSyncContentUpdatedMetadata::from_extract(
        DOCUMENT_ID.to_string(),
        FileType::Md,
        None,
        Some("not-an-actor".to_string()),
        Some("also-not-a-user".to_string()),
    );
    assert_eq!(metadata.actor, None);
    assert_eq!(metadata.on_behalf_of, None);
}