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.0 KB
Raw Blame
use chrono::{DateTime, Utc};
use macro_db_migrator::MACRO_DB_MIGRATIONS;
use model_owner::{Owner, OwnerType};
use shared_entity_registry::{InsertOutcome, NewEntityRecord, RegisteredEntityType, WriteOutcome};
use sqlx::{PgPool, Postgres, Transaction};
use uuid::Uuid;

use super::{clear_deleted, delete_entity, insert_entity, mark_deleted, touch_updated};

fn user_owner() -> Owner {
    Owner::parse(OwnerType::User, "macro|[email protected]").unwrap()
}

fn bot_owner() -> Owner {
    Owner::parse(OwnerType::Bot, "bot|00000000-0000-0000-0000-00000000a1a1").unwrap()
}

fn team_owner() -> Owner {
    Owner::parse(OwnerType::Team, "01234567-89ab-cdef-0123-456789abcdef").unwrap()
}

fn ts(rfc3339: &str) -> DateTime<Utc> {
    DateTime::parse_from_rfc3339(rfc3339)
        .unwrap()
        .with_timezone(&Utc)
}

async fn insert(tx: &mut Transaction<'_, Postgres>, record: NewEntityRecord) -> InsertOutcome {
    insert_entity(tx, record).await.unwrap()
}

#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
async fn insert_registers_a_row_for_each_registered_kind(pool: PgPool) {
    let owner = user_owner();
    let mut tx = pool.begin().await.unwrap();
    for (index, kind) in RegisteredEntityType::ALL.into_iter().enumerate() {
        let id = Uuid::from_u128(index as u128 + 1);
        assert_eq!(
            insert(&mut tx, NewEntityRecord::new(id, kind, owner.clone())).await,
            InsertOutcome::Inserted
        );
        let row = sqlx::query!(
            r#"
            SELECT entity_type
            FROM entity
            WHERE id = $1
            "#,
            id,
        )
        .fetch_one(tx.as_mut())
        .await
        .unwrap();
        assert_eq!(row.entity_type, kind.as_str());
    }
}

#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
async fn insert_twice_is_a_no_op(pool: PgPool) {
    let id = Uuid::from_u128(1);
    let first = user_owner();
    let second = bot_owner();
    let mut tx = pool.begin().await.unwrap();

    assert_eq!(
        insert(
            &mut tx,
            NewEntityRecord::new(id, RegisteredEntityType::Chat, first.clone())
        )
        .await,
        InsertOutcome::Inserted
    );
    assert_eq!(
        insert(
            &mut tx,
            NewEntityRecord::new(id, RegisteredEntityType::Document, second)
        )
        .await,
        InsertOutcome::AlreadyRegistered
    );

    let rows = sqlx::query!(
        r#"
        SELECT owner_type AS "owner_type: OwnerType", owner_id, entity_type
        FROM entity
        WHERE id = $1
        "#,
        id,
    )
    .fetch_all(tx.as_mut())
    .await
    .unwrap();
    assert_eq!(rows.len(), 1);
    assert_eq!(rows[0].owner_type, OwnerType::User);
    assert_eq!(rows[0].owner_id, first.principal_id());
    assert_eq!(rows[0].entity_type, "chat");
}

#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
async fn insert_encodes_user_bot_and_team_owners(pool: PgPool) {
    let cases = [
        (
            Uuid::from_u128(1),
            user_owner(),
            OwnerType::User,
            "macro|[email protected]",
        ),
        (
            Uuid::from_u128(2),
            bot_owner(),
            OwnerType::Bot,
            "bot|00000000-0000-0000-0000-00000000a1a1",
        ),
        (
            Uuid::from_u128(3),
            team_owner(),
            OwnerType::Team,
            "01234567-89ab-cdef-0123-456789abcdef",
        ),
    ];
    let mut tx = pool.begin().await.unwrap();
    for (id, owner, owner_type, owner_id) in cases {
        assert_eq!(
            insert(
                &mut tx,
                NewEntityRecord::new(id, RegisteredEntityType::Project, owner)
            )
            .await,
            InsertOutcome::Inserted
        );
        let row = sqlx::query!(
            r#"
            SELECT owner_type AS "owner_type: OwnerType", owner_id
            FROM entity
            WHERE id = $1
            "#,
            id,
        )
        .fetch_one(tx.as_mut())
        .await
        .unwrap();
        assert_eq!(row.owner_type, owner_type);
        assert_eq!(row.owner_id, owner_id);
    }
}

#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
async fn insert_without_timestamps_matches_transaction_now(pool: PgPool) {
    let id = Uuid::from_u128(1);
    let mut tx = pool.begin().await.unwrap();
    let now = sqlx::query_scalar!(r#"SELECT now() AS "now!""#)
        .fetch_one(tx.as_mut())
        .await
        .unwrap();

    insert(
        &mut tx,
        NewEntityRecord::new(id, RegisteredEntityType::Chat, user_owner()),
    )
    .await;

    let row = sqlx::query!(
        r#"
        SELECT created_at, updated_at
        FROM entity
        WHERE id = $1
        "#,
        id,
    )
    .fetch_one(tx.as_mut())
    .await
    .unwrap();
    assert_eq!(row.created_at, now);
    assert_eq!(row.updated_at, now);
}

#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
async fn insert_with_timestamps_stores_them(pool: PgPool) {
    let id = Uuid::from_u128(1);
    let created_at = ts("2024-03-15T12:00:00Z");
    let updated_at = ts("2024-03-16T08:30:00Z");
    let mut tx = pool.begin().await.unwrap();

    insert(
        &mut tx,
        NewEntityRecord::new(id, RegisteredEntityType::Document, user_owner())
            .with_timestamps(created_at, updated_at),
    )
    .await;

    let row = sqlx::query!(
        r#"
        SELECT created_at, updated_at, deleted_at
        FROM entity
        WHERE id = $1
        "#,
        id,
    )
    .fetch_one(tx.as_mut())
    .await
    .unwrap();
    assert_eq!(row.created_at, created_at);
    assert_eq!(row.updated_at, updated_at);
    assert_eq!(row.deleted_at, None);
}

#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
async fn mark_deleted_sets_the_instant_and_last_write_wins(pool: PgPool) {
    let id = Uuid::from_u128(1);
    let first = ts("2024-01-01T00:00:00Z");
    let second = ts("2024-01-02T00:00:00Z");
    let mut tx = pool.begin().await.unwrap();
    insert(
        &mut tx,
        NewEntityRecord::new(id, RegisteredEntityType::Chat, user_owner()),
    )
    .await;

    assert_eq!(
        mark_deleted(&mut tx, id, first).await.unwrap(),
        WriteOutcome::Applied
    );
    let after_first = sqlx::query!(
        r#"
        SELECT deleted_at
        FROM entity
        WHERE id = $1
        "#,
        id,
    )
    .fetch_one(tx.as_mut())
    .await
    .unwrap();
    assert_eq!(after_first.deleted_at, Some(first));

    assert_eq!(
        mark_deleted(&mut tx, id, second).await.unwrap(),
        WriteOutcome::Applied
    );
    let after_second = sqlx::query!(
        r#"
        SELECT deleted_at
        FROM entity
        WHERE id = $1
        "#,
        id,
    )
    .fetch_one(tx.as_mut())
    .await
    .unwrap();
    assert_eq!(after_second.deleted_at, Some(second));
}

#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
async fn mark_deleted_on_missing_row_is_not_found_not_error(pool: PgPool) {
    let mut tx = pool.begin().await.unwrap();
    assert_eq!(
        mark_deleted(&mut tx, Uuid::from_u128(99), ts("2024-01-01T00:00:00Z"))
            .await
            .unwrap(),
        WriteOutcome::NotFound
    );
}

#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
async fn clear_deleted_nulls_deleted_at(pool: PgPool) {
    let id = Uuid::from_u128(1);
    let mut tx = pool.begin().await.unwrap();
    insert(
        &mut tx,
        NewEntityRecord::new(id, RegisteredEntityType::Chat, user_owner()),
    )
    .await;
    mark_deleted(&mut tx, id, ts("2024-01-01T00:00:00Z"))
        .await
        .unwrap();

    assert_eq!(
        clear_deleted(&mut tx, id).await.unwrap(),
        WriteOutcome::Applied
    );
    let row = sqlx::query!(
        r#"
        SELECT deleted_at
        FROM entity
        WHERE id = $1
        "#,
        id,
    )
    .fetch_one(tx.as_mut())
    .await
    .unwrap();
    assert_eq!(row.deleted_at, None);
}

#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
async fn touch_updated_sets_updated_at_only(pool: PgPool) {
    let id = Uuid::from_u128(1);
    let created_at = ts("2024-03-15T12:00:00Z");
    let original_updated = ts("2024-03-16T08:30:00Z");
    let touched = ts("2024-04-01T00:00:00Z");
    let mut tx = pool.begin().await.unwrap();
    insert(
        &mut tx,
        NewEntityRecord::new(id, RegisteredEntityType::Chat, user_owner())
            .with_timestamps(created_at, original_updated),
    )
    .await;

    assert_eq!(
        touch_updated(&mut tx, id, touched).await.unwrap(),
        WriteOutcome::Applied
    );
    let row = sqlx::query!(
        r#"
        SELECT created_at, updated_at, deleted_at
        FROM entity
        WHERE id = $1
        "#,
        id,
    )
    .fetch_one(tx.as_mut())
    .await
    .unwrap();
    assert_eq!(row.created_at, created_at);
    assert_eq!(row.updated_at, touched);
    assert_eq!(row.deleted_at, None);
}

#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
async fn delete_entity_removes_the_row_and_reports_not_found_second_time(pool: PgPool) {
    let id = Uuid::from_u128(1);
    let mut tx = pool.begin().await.unwrap();
    insert(
        &mut tx,
        NewEntityRecord::new(id, RegisteredEntityType::Chat, user_owner()),
    )
    .await;

    assert_eq!(
        delete_entity(&mut tx, id).await.unwrap(),
        WriteOutcome::Applied
    );
    let missing = sqlx::query_scalar!(
        r#"
        SELECT count(*) AS "count!"
        FROM entity
        WHERE id = $1
        "#,
        id,
    )
    .fetch_one(tx.as_mut())
    .await
    .unwrap();
    assert_eq!(missing, 0);
    assert_eq!(
        delete_entity(&mut tx, id).await.unwrap(),
        WriteOutcome::NotFound
    );
}

#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
async fn helpers_never_commit(pool: PgPool) {
    let id = Uuid::from_u128(1);
    let mut tx = pool.begin().await.unwrap();
    insert(
        &mut tx,
        NewEntityRecord::new(id, RegisteredEntityType::Chat, user_owner()),
    )
    .await;
    tx.rollback().await.unwrap();

    let count = sqlx::query_scalar!(
        r#"
        SELECT count(*) AS "count!"
        FROM entity
        WHERE id = $1
        "#,
        id,
    )
    .fetch_one(&pool)
    .await
    .unwrap();
    assert_eq!(count, 0);
}