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.8 KB
Raw Blame
use std::sync::{
    Arc, Mutex,
    atomic::{AtomicBool, Ordering},
};

use macro_event_broker::{EventBrokerError, MacroEvent, MacroEventBroker};
use model_owner::Owner;
use shared_entity_registry::{OwnedPurgeOutcome, PurgeOwnedEntity};
use tokio::task::JoinHandle;
use uuid::Uuid;

use super::{
    DocumentPurgeQueue, DocumentPurgeRepository, DocumentPurgeService, DocumentPurger,
    DocxPartReferences, PurgeTarget, PurgedRows,
};
use crate::domain::models::DocumentError;

const OWNER: &str = "macro|[email protected]";

#[derive(Clone, Copy, Default)]
enum BrokerFailure {
    #[default]
    None,
    BeforeSpawn,
    DuringDelivery,
    Cancelled,
}

struct State {
    steps: Mutex<Vec<(&'static str, String)>>,
    document: Mutex<Option<PurgeTarget>>,
    part_shas: Vec<String>,
    fail_rows: AtomicBool,
    fail_queue: AtomicBool,
    fail_release: AtomicBool,
    broker_failure: BrokerFailure,
}

impl Default for State {
    fn default() -> Self {
        Self {
            steps: Mutex::default(),
            document: Mutex::new(Some(PurgeTarget {
                owner: owner(),
                file_type: Some("pdf".to_owned()),
            })),
            part_shas: Vec::new(),
            fail_rows: AtomicBool::default(),
            fail_queue: AtomicBool::default(),
            fail_release: AtomicBool::default(),
            broker_failure: BrokerFailure::default(),
        }
    }
}

impl State {
    fn docx(part_shas: &[&str]) -> Self {
        Self {
            document: Mutex::new(Some(PurgeTarget {
                owner: owner(),
                file_type: Some("docx".to_owned()),
            })),
            part_shas: part_shas.iter().map(|sha| (*sha).to_owned()).collect(),
            ..Self::default()
        }
    }

    fn missing() -> Self {
        Self {
            document: Mutex::new(None),
            ..Self::default()
        }
    }

    fn record(&self, step: &'static str, detail: &str) {
        self.steps.lock().unwrap().push((step, detail.to_owned()));
    }

    fn steps(&self) -> Vec<(&'static str, String)> {
        self.steps.lock().unwrap().clone()
    }

    fn exists(&self) -> bool {
        self.document.lock().unwrap().is_some()
    }
}

fn owner() -> Owner {
    Owner::from_principal_str(OWNER).unwrap()
}

impl DocumentPurgeRepository for Arc<State> {
    async fn find(&self, document_id: &str) -> Result<Option<PurgeTarget>, DocumentError> {
        self.record("find", document_id);
        Ok(self.document.lock().unwrap().clone())
    }

    async fn purge_rows(
        &self,
        document_id: &str,
        target: &PurgeTarget,
    ) -> Result<PurgedRows, DocumentError> {
        self.record("rows", document_id);
        if self.fail_rows.load(Ordering::SeqCst) {
            return Err(DocumentError::Internal(anyhow::anyhow!(
                "row deletion failed"
            )));
        }
        self.document.lock().unwrap().take();
        let docx_part_shas = if target.file_type.as_deref() == Some("docx") {
            self.part_shas.clone()
        } else {
            Vec::new()
        };
        Ok(PurgedRows { docx_part_shas })
    }
}

impl DocumentPurgeQueue for Arc<State> {
    async fn enqueue(&self, document_id: String, owner: Owner) -> Result<(), DocumentError> {
        self.record("queue", &document_id);
        assert_eq!(owner.principal_id(), OWNER);
        if self.fail_queue.load(Ordering::SeqCst) {
            return Err(DocumentError::Internal(anyhow::anyhow!(
                "queue unavailable"
            )));
        }
        Ok(())
    }
}

impl DocxPartReferences for Arc<State> {
    async fn release(&self, shas: Vec<String>) -> Result<(), DocumentError> {
        self.record("release", &shas.join(","));
        if self.fail_release.load(Ordering::SeqCst) {
            return Err(DocumentError::Internal(anyhow::anyhow!(
                "sha counter unavailable"
            )));
        }
        Ok(())
    }
}

struct Broker(Arc<State>);

impl MacroEventBroker for Broker {
    fn send_event<E: MacroEvent + ?Sized>(
        &self,
        event: &E,
    ) -> Result<JoinHandle<Result<(), EventBrokerError>>, EventBrokerError> {
        self.0.record("broker", event.key());
        // Every retry uses the same document identity for queue and event consumers.
        let payload = serde_json::to_value(event.event())?;
        assert_eq!(payload["event_type"], "document.purged");
        assert_eq!(payload["metadata"]["document_id"], event.key());
        match self.0.broker_failure {
            BrokerFailure::BeforeSpawn => {
                Err(EventBrokerError::Publish("broker unavailable".into()))
            }
            BrokerFailure::DuringDelivery => Ok(tokio::spawn(async {
                Err(EventBrokerError::Publish("delivery failed".into()))
            })),
            BrokerFailure::Cancelled => {
                let delivery = tokio::spawn(std::future::pending());
                delivery.abort();
                Ok(delivery)
            }
            BrokerFailure::None => Ok(tokio::spawn(async { Ok(()) })),
        }
    }
}

fn purger(state: &Arc<State>) -> DocumentPurger<Arc<State>, Arc<State>, Arc<State>, Broker> {
    DocumentPurger::new(
        state.clone(),
        state.clone(),
        state.clone(),
        Broker(state.clone()),
    )
}

fn steps(id: Uuid, names: &[&'static str]) -> Vec<(&'static str, String)> {
    names.iter().map(|name| (*name, id.to_string())).collect()
}

#[tokio::test]
async fn purge_enqueues_and_publishes_before_deleting_the_rows() {
    let state = Arc::new(State::default());
    let id = Uuid::now_v7();
    purger(&state).purge(id).await.unwrap();
    assert_eq!(
        state.steps(),
        steps(id, &["find", "queue", "broker", "rows"])
    );
    assert!(!state.exists());
}

#[tokio::test]
async fn queue_failure_stops_before_the_event_and_the_rows() {
    let state = Arc::new(State {
        fail_queue: AtomicBool::new(true),
        ..State::default()
    });
    let id = Uuid::now_v7();
    assert!(purger(&state).purge(id).await.is_err());
    assert_eq!(state.steps(), steps(id, &["find", "queue"]));
    assert!(state.exists());
}

#[tokio::test]
async fn broker_start_failure_keeps_the_rows() {
    let state = Arc::new(State {
        broker_failure: BrokerFailure::BeforeSpawn,
        ..State::default()
    });
    let id = Uuid::now_v7();
    assert!(purger(&state).purge(id).await.is_err());
    assert_eq!(state.steps(), steps(id, &["find", "queue", "broker"]));
    assert!(state.exists());
}

#[tokio::test]
async fn broker_delivery_failure_is_awaited_and_keeps_the_rows() {
    let state = Arc::new(State {
        broker_failure: BrokerFailure::DuringDelivery,
        ..State::default()
    });
    let id = Uuid::now_v7();
    assert!(purger(&state).purge(id).await.is_err());
    assert_eq!(state.steps(), steps(id, &["find", "queue", "broker"]));
    assert!(state.exists());
}

#[tokio::test]
async fn cancelled_broker_delivery_keeps_the_rows() {
    let state = Arc::new(State {
        broker_failure: BrokerFailure::Cancelled,
        ..State::default()
    });
    let id = Uuid::now_v7();
    assert!(purger(&state).purge(id).await.is_err());
    assert_eq!(state.steps(), steps(id, &["find", "queue", "broker"]));
    assert!(state.exists());
}

#[tokio::test]
async fn row_failure_leaves_the_document_for_a_retry() {
    let state = Arc::new(State {
        fail_rows: AtomicBool::new(true),
        ..State::default()
    });
    let id = Uuid::now_v7();
    let service = purger(&state);
    assert!(service.purge(id).await.is_err());
    assert!(state.exists());

    state.fail_rows.store(false, Ordering::SeqCst);
    service.purge(id).await.unwrap();
    assert_eq!(
        state.steps(),
        steps(
            id,
            &[
                "find", "queue", "broker", "rows", "find", "queue", "broker", "rows"
            ]
        )
    );
    assert!(!state.exists());
}

#[tokio::test]
async fn docx_parts_are_released_after_the_rows_are_gone() {
    let state = Arc::new(State::docx(&["b", "a", "b"]));
    let id = Uuid::now_v7();
    purger(&state).purge(id).await.unwrap();
    let mut expected = steps(id, &["find", "queue", "broker", "rows"]);
    expected.push(("release", "b,a,b".to_owned()));
    assert_eq!(state.steps(), expected);
}

#[tokio::test]
async fn docx_parts_are_released_once_across_a_failed_attempt_and_its_retry() {
    let state = Arc::new(State {
        fail_rows: AtomicBool::new(true),
        ..State::docx(&["a"])
    });
    let id = Uuid::now_v7();
    let service = purger(&state);
    assert!(service.purge(id).await.is_err());
    state.fail_rows.store(false, Ordering::SeqCst);
    service.purge(id).await.unwrap();

    let mut expected = steps(
        id,
        &[
            "find", "queue", "broker", "rows", "find", "queue", "broker", "rows",
        ],
    );
    expected.push(("release", "a".to_owned()));
    assert_eq!(state.steps(), expected);
}

#[tokio::test]
async fn release_failure_after_the_rows_are_gone_still_purges() {
    let state = Arc::new(State {
        fail_release: AtomicBool::new(true),
        ..State::docx(&["a"])
    });
    let id = Uuid::now_v7();
    purger(&state).purge(id).await.unwrap();
    assert_eq!(state.steps().last(), Some(&("release", "a".to_owned())));
    assert!(!state.exists());
}

#[tokio::test]
async fn purge_of_a_missing_document_does_nothing() {
    let state = Arc::new(State::missing());
    let id = Uuid::now_v7();
    purger(&state).purge(id).await.unwrap();
    assert_eq!(state.steps(), steps(id, &["find"]));
}

#[tokio::test]
async fn purge_owned_of_a_missing_document_is_purged() {
    let state = Arc::new(State::missing());
    let id = Uuid::now_v7();
    assert_eq!(
        purger(&state).purge_owned(id, &owner()).await.unwrap(),
        OwnedPurgeOutcome::Purged
    );
    assert_eq!(state.steps(), steps(id, &["find"]));
}

#[tokio::test]
async fn purge_owned_refuses_a_document_owned_by_someone_else() {
    let state = Arc::new(State::default());
    let id = Uuid::now_v7();
    let team = Owner::Team(Uuid::from_u128(1));
    assert_eq!(
        purger(&state).purge_owned(id, &team).await.unwrap(),
        OwnedPurgeOutcome::OwnedElsewhere
    );
    assert_eq!(state.steps(), steps(id, &["find"]));
    assert!(state.exists());
}

#[tokio::test]
async fn purge_owned_of_the_expected_owner_purges() {
    let state = Arc::new(State::default());
    let id = Uuid::now_v7();
    assert_eq!(
        purger(&state).purge_owned(id, &owner()).await.unwrap(),
        OwnedPurgeOutcome::Purged
    );
    assert_eq!(
        state.steps(),
        steps(id, &["find", "queue", "broker", "rows"])
    );
    assert!(!state.exists());
}

#[tokio::test]
async fn purge_owned_returns_a_failed_purge_as_an_error() {
    let state = Arc::new(State {
        fail_queue: AtomicBool::new(true),
        ..State::default()
    });
    let id = Uuid::now_v7();
    assert!(purger(&state).purge_owned(id, &owner()).await.is_err());
    assert!(state.exists());
}