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.

4.4 KB
Raw Blame
use std::sync::{Arc, Mutex};

use macro_db_migrator::MACRO_DB_MIGRATIONS;
use macro_event_broker::NoopMacroEventBroker;
use model_owner::Owner;
use sqlx::PgPool;
use uuid::Uuid;

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

const DOCX: &str = "93000000-0000-0000-0000-000000000011";

struct CapturingQueue {
    pool: PgPool,
    documents: Mutex<Vec<(String, Owner)>>,
}

impl DocumentPurgeQueue for Arc<CapturingQueue> {
    async fn enqueue(&self, document_id: String, owner: Owner) -> Result<(), DocumentError> {
        let stored = macro_db_client::document::get_deleted_document_info(&self.pool, &document_id)
            .await
            .unwrap();
        assert_eq!(stored.owner, owner);
        self.documents.lock().unwrap().push((document_id, owner));
        Ok(())
    }
}

struct RecordingPartReferences {
    pool: PgPool,
    released: Mutex<Vec<Vec<String>>>,
}

impl DocxPartReferences for Arc<RecordingPartReferences> {
    async fn release(&self, mut shas: Vec<String>) -> Result<(), DocumentError> {
        let deleted = macro_db_client::document::get_deleted_document_info(&self.pool, DOCX).await;
        assert!(matches!(deleted, Err(sqlx::Error::RowNotFound)));
        shas.sort();
        self.released.lock().unwrap().push(shas);
        Ok(())
    }
}

struct Fixture {
    queue: Arc<CapturingQueue>,
    part_references: Arc<RecordingPartReferences>,
    purger: DocumentPurger<
        LegacyDocumentPurgeRepository,
        Arc<CapturingQueue>,
        Arc<RecordingPartReferences>,
        NoopMacroEventBroker,
    >,
}

fn fixture(pool: &PgPool) -> Fixture {
    let queue = Arc::new(CapturingQueue {
        pool: pool.clone(),
        documents: Mutex::default(),
    });
    let part_references = Arc::new(RecordingPartReferences {
        pool: pool.clone(),
        released: Mutex::default(),
    });
    let purger = DocumentPurger::new(
        LegacyDocumentPurgeRepository::new(pool.clone()),
        queue.clone(),
        part_references.clone(),
        NoopMacroEventBroker,
    );
    Fixture {
        queue,
        part_references,
        purger,
    }
}

#[sqlx::test(
    migrator = "MACRO_DB_MIGRATIONS",
    fixtures(
        path = "../../../../entity_access/fixtures",
        scripts("typed_owner_team")
    )
)]
async fn queues_the_stored_owner_before_deleting_the_document(pool: PgPool) {
    let fixture = fixture(&pool);
    let expected = [
        (
            "90000000-0000-0000-0000-000000000031",
            "macro|[email protected]",
        ),
        (
            "90000000-0000-0000-0000-000000000033",
            "90000000-0000-0000-0000-000000000011",
        ),
        (
            "90000000-0000-0000-0000-000000000034",
            "bot|90000000-0000-0000-0000-000000000021",
        ),
    ];
    for (id, _) in expected {
        fixture
            .purger
            .purge(Uuid::parse_str(id).unwrap())
            .await
            .unwrap();
    }
    assert_eq!(
        *fixture.queue.documents.lock().unwrap(),
        expected.map(|(id, owner)| (id.to_owned(), Owner::from_principal_str(owner).unwrap()))
    );
    let repository = LegacyDocumentPurgeRepository::new(pool);
    for (id, _) in expected {
        assert_eq!(repository.find(id).await.unwrap(), None);
    }
    assert!(fixture.part_references.released.lock().unwrap().is_empty());
}

#[sqlx::test(
    migrator = "MACRO_DB_MIGRATIONS",
    fixtures(path = "../../../fixtures", scripts("docx_purge"))
)]
async fn releases_each_docx_part_reference_once_the_rows_are_gone(pool: PgPool) {
    let fixture = fixture(&pool);
    fixture
        .purger
        .purge(Uuid::parse_str(DOCX).unwrap())
        .await
        .unwrap();
    assert_eq!(
        *fixture.part_references.released.lock().unwrap(),
        vec![vec![
            "sha-a".to_owned(),
            "sha-a".to_owned(),
            "sha-b".to_owned()
        ]]
    );
    assert!(
        macro_db_client::document::get_bom_parts(&pool, DOCX)
            .await
            .unwrap()
            .is_empty()
    );
}

#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
async fn purge_of_a_missing_document_is_ok(pool: PgPool) {
    let fixture = fixture(&pool);
    fixture.purger.purge(Uuid::now_v7()).await.unwrap();
    assert!(fixture.queue.documents.lock().unwrap().is_empty());
}