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.

15.6 KB
Raw Blame
use super::*;
use crate::domain::ports::editing::MockEditingWorkerService;
use entity_access::domain::models::{Entity, EntityPermission, EntityType, RequiredPermission};
use models_permissions::share_permission::access_level::AccessLevel;

const DOCUMENT: &str = "019fd3b9-3c6c-7c05-89c2-a27f0121813b";
const SECRET: &str = "local-spreadsheet-test-secret";
fn user() -> MacroUserIdStr<'static> {
    MacroUserIdStr::try_from("macro|[email protected]".to_owned()).unwrap()
}
fn receipt<T: RequiredPermission>(access_level: AccessLevel) -> EntityAccessReceipt<T> {
    EntityAccessReceipt::try_new_authenticated_user(
        user(),
        Entity {
            entity_id: DOCUMENT.to_owned(),
            entity_type: EntityType::Document,
        },
        EntityPermission::AccessLevel { access_level },
    )
    .unwrap()
}
fn request() -> SpreadsheetRequest {
    SpreadsheetRequest::Read {
        sheet_id: None,
        ranges: None,
        include_styles: None,
    }
}
fn response() -> SpreadsheetResponse {
    SpreadsheetResponse::Read {
        revision: "revision".into(),
        sheets: vec![],
        ranges: vec![],
        warnings: vec![],
    }
}
fn lookup(file_type: &str) -> MockSpreadsheetDocumentLookup {
    let mut lookup = MockSpreadsheetDocumentLookup::new();
    let file_type = file_type.to_owned();
    lookup
        .expect_file_type()
        .withf(|id| id == DOCUMENT)
        .times(1)
        .returning(move |_| {
            let file_type = file_type.clone();
            Box::pin(async move { Ok(Some(file_type)) })
        });
    lookup
}

#[tokio::test]
async fn reads_mint_only_view_access_and_preserve_delegated_actor() {
    let mut worker = MockEditingWorkerService::new();
    worker
        .expect_spreadsheet()
        .times(1)
        .returning(|id, token, request| {
            assert_eq!(id, DOCUMENT);
            assert!(matches!(request, SpreadsheetRequest::Read { .. }));
            let claims: serde_json::Value =
                macro_sync_service_jwt::decode(token.as_str(), SECRET).unwrap();
            assert_eq!(claims["document_id"], DOCUMENT);
            assert_eq!(claims["access_level"], "view");
            assert_eq!(claims["user_id"], "macro|[email protected]");
            assert_eq!(claims["actor"], "macro|[email protected]");
            Box::pin(async { Ok(response()) })
        });
    let service = SpreadsheetService::new(
        Arc::new(lookup("spreadsheet")),
        Arc::new(worker),
        SECRET.into(),
    );
    service
        .read(
            receipt(AccessLevel::View),
            &user(),
            "macro|[email protected]",
            request(),
        )
        .await
        .unwrap();
}

#[tokio::test]
async fn edits_forward_exact_revision_with_edit_token() {
    let mut worker = MockEditingWorkerService::new();
    worker.expect_spreadsheet().times(1).returning(|_, token, request| {
        let claims: serde_json::Value = macro_sync_service_jwt::decode(token.as_str(), SECRET).unwrap();
        assert_eq!(claims["access_level"], "edit");
        assert!(matches!(request, SpreadsheetRequest::Edit { expected_revision, operations } if expected_revision == "seen" && operations.len() == 1));
        Box::pin(async { Ok(response()) })
    });
    let service = SpreadsheetService::new(
        Arc::new(lookup("spreadsheet")),
        Arc::new(worker),
        SECRET.into(),
    );
    service
        .edit(
            receipt(AccessLevel::Edit),
            &user(),
            "macro|[email protected]",
            "seen".into(),
            vec![SpreadsheetOperation::AddSheet {
                name: "Forecast".into(),
            }],
        )
        .await
        .unwrap();
}

#[tokio::test]
async fn imported_files_cannot_enter_native_spreadsheet_worker() {
    let worker = MockEditingWorkerService::new();
    let service =
        SpreadsheetService::new(Arc::new(lookup("xlsx")), Arc::new(worker), SECRET.into());
    let error = service
        .read(
            receipt(AccessLevel::View),
            &user(),
            "macro|[email protected]",
            request(),
        )
        .await
        .unwrap_err();
    assert!(error.to_string().contains("native Macro spreadsheet"));
}

#[tokio::test]
async fn read_receipt_cannot_smuggle_an_edit_request() {
    let service = SpreadsheetService::new(
        Arc::new(MockSpreadsheetDocumentLookup::new()),
        Arc::new(MockEditingWorkerService::new()),
        SECRET.into(),
    );
    let error = service
        .read(
            receipt(AccessLevel::View),
            &user(),
            "macro|[email protected]",
            SpreadsheetRequest::Edit {
                expected_revision: "r".into(),
                operations: vec![],
            },
        )
        .await
        .unwrap_err();
    assert!(error.to_string().contains("edit access"));
}

#[tokio::test]
async fn missing_revision_or_empty_batch_never_calls_ports() {
    let service = SpreadsheetService::new(
        Arc::new(MockSpreadsheetDocumentLookup::new()),
        Arc::new(MockEditingWorkerService::new()),
        SECRET.into(),
    );
    assert!(
        service
            .edit(
                receipt(AccessLevel::Edit),
                &user(),
                "macro|[email protected]",
                "".into(),
                vec![]
            )
            .await
            .is_err()
    );
    assert!(
        service
            .edit(
                receipt(AccessLevel::Edit),
                &user(),
                "macro|[email protected]",
                "r".into(),
                vec![]
            )
            .await
            .is_err()
    );
}

#[test]
fn view_and_comment_permissions_cannot_mint_edit_receipt() {
    for access_level in [AccessLevel::View, AccessLevel::Comment] {
        assert!(
            EntityAccessReceipt::<EditAccessLevel>::try_new_authenticated_user(
                user(),
                Entity {
                    entity_id: DOCUMENT.to_owned(),
                    entity_type: EntityType::Document
                },
                EntityPermission::AccessLevel { access_level }
            )
            .is_err()
        );
    }
}

#[test]
fn worker_json_contract_omits_optional_fields_and_round_trips_response() {
    assert_eq!(
        serde_json::to_value(request()).unwrap(),
        serde_json::json!({"action":"read"})
    );
    let parsed: SpreadsheetResponse = serde_json::from_value(serde_json::json!({
        "action":"read", "revision":"r", "warnings":[],
        "sheets":[{"id":"sheet1","name":"Sheet1","rowCount":200,"columnCount":26,"usedRange":"A1:A1","populatedCells":1,"formulaCells":1,"errorCells":0}],
        "ranges":[{"sheetId":"sheet1","sheetName":"Sheet1","range":"A1","truncated":false,"cells":[{"address":"A1","source":"=1+1","formula":"=1+1","type":"number","value":2,"display":"2"}]}]
    })).unwrap();
    assert!(
        matches!(parsed, SpreadsheetResponse::Read { ranges, .. } if ranges[0].cells[0].source == "=1+1")
    );
}

#[test]
fn dropdown_operations_and_read_validations_match_the_worker_contract() {
    let operation: SpreadsheetOperation = serde_json::from_value(serde_json::json!({
        "type": "set_dropdown", "sheetId": "sheet1", "range": "B2:B50",
        "items": ["Open", "Done"], "rejectInvalid": false
    }))
    .unwrap();
    assert_eq!(
        serde_json::to_value(&operation).unwrap(),
        serde_json::json!({
            "type": "set_dropdown", "sheetId": "sheet1", "range": "B2:B50",
            "items": ["Open", "Done"], "rejectInvalid": false
        })
    );
    assert_eq!(
        serde_json::to_value(SpreadsheetOperation::ClearValidation {
            sheet_id: "sheet1".into(),
            range: "B2".into(),
        })
        .unwrap(),
        serde_json::json!({"type": "clear_validation", "sheetId": "sheet1", "range": "B2"})
    );
    let parsed: SpreadsheetResponse = serde_json::from_value(serde_json::json!({
        "action":"read", "revision":"r", "warnings":[], "sheets":[],
        "ranges":[{"sheetId":"sheet1","sheetName":"Sheet1","range":"B2","truncated":false,"cells":[],
            "validations":[{"range":"B2:B50","type":"list","items":["Open","Done"],"dropdown":true,"rejectInvalid":true}]}]
    }))
    .unwrap();
    let SpreadsheetResponse::Read { ranges, .. } = parsed else {
        panic!("expected a read response");
    };
    assert_eq!(ranges[0].validations[0].kind, "list");
    assert_eq!(
        ranges[0].validations[0].items.as_deref(),
        Some(&["Open".to_owned(), "Done".to_owned()][..])
    );
    assert!(ranges[0].validations[0].reject_invalid);
}

#[test]
fn table_operations_and_summaries_match_the_worker_contract() {
    let operation: SpreadsheetOperation = serde_json::from_value(serde_json::json!({
        "type": "create_table", "sheetId": "sheet1", "range": "A1:D20",
        "name": "Sales", "totalsRow": true,
        "columnTypes": [{"column": "Status", "type": "dropdown"}, {"column": "Price", "type": "currency"}]
    }))
    .unwrap();
    assert_eq!(
        serde_json::to_value(&operation).unwrap(),
        serde_json::json!({
            "type": "create_table", "sheetId": "sheet1", "range": "A1:D20",
            "name": "Sales", "totalsRow": true,
            "columnTypes": [{"column": "Status", "type": "dropdown"}, {"column": "Price", "type": "currency"}]
        })
    );
    assert!(
        serde_json::from_value::<SpreadsheetOperation>(serde_json::json!({
            "type": "create_table", "sheetId": "sheet1", "range": "A1:D20",
            "columnTypes": [{"column": "Price", "type": "money"}]
        }))
        .is_err()
    );
    assert_eq!(
        serde_json::to_value(SpreadsheetOperation::CreateTable {
            sheet_id: "sheet1".into(),
            range: "A1:B5".into(),
            name: None,
            totals_row: None,
            column_types: None,
        })
        .unwrap(),
        serde_json::json!({"type": "create_table", "sheetId": "sheet1", "range": "A1:B5"})
    );
    let parsed: SpreadsheetResponse = serde_json::from_value(serde_json::json!({
        "action":"read", "revision":"r", "warnings":[], "ranges":[],
        "sheets":[
            {"id":"sheet1","name":"Data","rowCount":200,"columnCount":26,"usedRange":"A1:D21",
             "populatedCells":84,"formulaCells":21,"errorCells":0,
             "tables":[{"name":"Sales","range":"A1:D21","columns":["Region","Qty","Price","Amount"],
                "totalsRow":true,"filteredColumns":["Region"],
                "columnTypes":[{"column":"Qty","type":"number"}]}]},
            {"id":"other","name":"Notes","rowCount":200,"columnCount":26,"usedRange":null,
             "populatedCells":0,"formulaCells":0,"errorCells":0}
        ]
    }))
    .unwrap();
    let SpreadsheetResponse::Read { sheets, .. } = parsed else {
        panic!("expected a read response");
    };
    assert_eq!(sheets[0].tables[0].name, "Sales");
    assert_eq!(sheets[0].tables[0].columns.len(), 4);
    assert!(sheets[0].tables[0].totals_row);
    assert_eq!(sheets[0].tables[0].filtered_columns, ["Region"]);
    assert_eq!(
        sheets[0].tables[0].column_types[0].column_type,
        SpreadsheetColumnType::Number
    );
    assert!(sheets[1].tables.is_empty());
    assert!(
        serde_json::to_value(&sheets[1])
            .unwrap()
            .get("tables")
            .is_none()
    );
}

#[test]
fn checkbox_operations_and_read_styles_match_the_worker_contract() {
    assert_eq!(
        serde_json::to_value(SpreadsheetOperation::InsertCheckboxes {
            sheet_id: "sheet1".into(),
            range: "D2:D50".into(),
        })
        .unwrap(),
        serde_json::json!({"type": "insert_checkboxes", "sheetId": "sheet1", "range": "D2:D50"})
    );
    let parsed: SpreadsheetResponse = serde_json::from_value(serde_json::json!({
        "action":"read", "revision":"r", "warnings":[], "sheets":[],
        "ranges":[{"sheetId":"sheet1","sheetName":"Sheet1","range":"D2","truncated":false,
            "cells":[{"address":"D2","source":"TRUE","type":"boolean","value":true,"display":"TRUE","style":{"checkbox":true}}]}]
    }))
    .unwrap();
    let SpreadsheetResponse::Read { ranges, .. } = parsed else {
        panic!("expected a read response");
    };
    assert_eq!(
        ranges[0].cells[0]
            .style
            .as_ref()
            .and_then(|style| style.checkbox),
        Some(true)
    );
}

#[test]
fn dropdown_colors_round_trip_through_the_worker_contract() {
    let json = serde_json::json!({
        "type": "set_dropdown", "sheetId": "sheet1", "range": "B2:B50",
        "items": ["Open", "Done"],
        "colors": [{"item": "Done", "color": "#D9EAD3"}]
    });
    let operation: SpreadsheetOperation = serde_json::from_value(json.clone()).unwrap();
    assert_eq!(serde_json::to_value(&operation).unwrap(), json);
    assert!(
        serde_json::from_value::<SpreadsheetOperation>(serde_json::json!({
            "type": "set_dropdown", "sheetId": "sheet1", "range": "B2",
            "items": ["Done"], "colors": [{"item": "Done", "color": "#D9EAD3", "text": "#000000"}]
        }))
        .is_err()
    );
    let parsed: SpreadsheetResponse = serde_json::from_value(serde_json::json!({
        "action":"read", "revision":"r", "warnings":[], "sheets":[],
        "ranges":[{"sheetId":"sheet1","sheetName":"Sheet1","range":"B2","truncated":false,"cells":[],
            "validations":[{"range":"B2:B50","type":"list","items":["Open","Done"],"dropdown":true,"rejectInvalid":true,
                "colors":[{"item":"Done","color":"#d9ead3"}]}]}]
    }))
    .unwrap();
    let SpreadsheetResponse::Read { ranges, .. } = parsed else {
        panic!("expected a read response");
    };
    let colors = ranges[0].validations[0].colors.as_deref().unwrap();
    assert_eq!(
        (colors[0].item.as_str(), colors[0].color.as_str()),
        ("Done", "#d9ead3")
    );
}

#[test]
fn imported_styles_round_trip_through_the_ai_contract() {
    let json = serde_json::json!({
        "numberFormat": "#,##0.00;[Red](#,##0.00)",
        "fontName": "Calibri",
        "borderBottomStyle": "double",
        "borderBottomColor": "#123456"
    });
    let style: super::models::SpreadsheetStyle = serde_json::from_value(json.clone()).unwrap();
    assert_eq!(serde_json::to_value(style).unwrap(), json);
    let accounting = serde_json::json!({"format": "accounting", "decimals": 0});
    let style: super::models::SpreadsheetStyle =
        serde_json::from_value(accounting.clone()).unwrap();
    assert!(matches!(
        style.format,
        Some(super::models::SpreadsheetNumberFormat::Accounting)
    ));
    assert_eq!(serde_json::to_value(style).unwrap(), accounting);
    assert!(
        serde_json::from_value::<super::models::SpreadsheetStyle>(
            serde_json::json!({"borderBottomStyle":"bogus"})
        )
        .is_err()
    );
}

#[test]
fn indented_cells_read_back_with_their_level() {
    let parsed: SpreadsheetResponse = serde_json::from_value(serde_json::json!({
        "action":"read", "revision":"r", "warnings":[], "sheets":[],
        "ranges":[{"sheetId":"sheet1","sheetName":"Sheet1","range":"A2","truncated":false,
            "cells":[{"address":"A2","source":"Product revenue","type":"text","value":"Product revenue",
                "display":"Product revenue","style":{"indent":2,"horizontalAlign":"left"}}]}]
    }))
    .unwrap();
    let SpreadsheetResponse::Read { ranges, .. } = parsed else {
        panic!("expected a read response");
    };
    assert_eq!(
        ranges[0].cells[0]
            .style
            .as_ref()
            .and_then(|style| style.indent),
        Some(2)
    );
    let operation: SpreadsheetOperation = serde_json::from_value(serde_json::json!({
        "type": "format_cells", "sheetId": "sheet1", "range": "A2:A4", "style": {"indent": 1}
    }))
    .unwrap();
    assert!(matches!(
        operation,
        SpreadsheetOperation::FormatCells { style, .. } if style.indent == Some(1)
    ));
}