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.

17.0 KB
Raw Blame
//! A form that created its own database goes by that database's name:
//! renaming either renames both, and every read names the form as the
//! database is named now. A form over an existing table keeps a name of its
//! own.

use ::databases::domain::models::DatabaseError;
use bot_id::BotId;
use entity_access::domain::models::{
    BotReceiptScope, EditAccessLevel, OwnerAccessLevel, ViewAccessLevel,
};

use super::*;
use crate::domain::models::{FormAccess, FormError, ListedForm, UpdateForm};
use crate::domain::ports::{CreateFormCommand, CreateSource, FormsService};

const PARTY_DATABASE: DatabaseId = DatabaseId::from_uuid(Uuid::from_u128(0xd9));
const PARTY_TABLE: TableId = TableId::from_uuid(Uuid::from_u128(0x7c));

/// A form over a new database of its own, named "Offsite RSVP", owned by
/// [`OWNER`] and edited by [`EDITOR`]: its id and its database's.
async fn create_standalone(world: &Shared) -> (FormId, DatabaseId) {
    let detail = service(world)
        .create_form(
            viewer(OWNER),
            CreateFormCommand {
                name: "Offsite RSVP".into(),
                source: CreateSource::NewDatabase {
                    is_hidden_in_drive: false,
                    anonymous: false,
                },
            },
        )
        .await
        .unwrap();
    (detail.form.id, detail.form.database_id)
}

/// A database "Party" with one table, owned by [`OWNER`].
fn seed_party(world: &Shared) {
    world.lock().unwrap().databases.push(FakeDatabase {
        id: PARTY_DATABASE,
        name: "Party".into(),
        owner: OWNER.into(),
        trashed: false,
        tables: vec![FakeTable {
            id: PARTY_TABLE,
            name: "Guests".into(),
            version: 1,
            columns: vec![FakeColumn {
                id: ColumnId::from_uuid(Uuid::from_u128(0xa1)),
                name: "Name".into(),
                kind: ColumnKind::Text,
                options: vec![],
            }],
            rows: vec![],
        }],
    });
}

/// A form named "Party RSVP" over the table of `database`.
async fn create_attached(world: &Shared, database: DatabaseId, table: TableId) -> FormId {
    service(world)
        .create_form(
            viewer(OWNER),
            CreateFormCommand {
                name: "Party RSVP".into(),
                source: CreateSource::Table {
                    receipt: database_receipt::<OwnerAccessLevel>(
                        database,
                        OWNER,
                        AccessLevel::Owner,
                    ),
                    table_id: table,
                },
            },
        )
        .await
        .unwrap()
        .form
        .id
}

fn stored(world: &Shared, id: FormId) -> StoredForm {
    world
        .lock()
        .unwrap()
        .forms
        .iter()
        .find(|stored| stored.form.id == id)
        .cloned()
        .expect("the form exists")
}

fn edit(form: FormId) -> EntityAccessReceipt<EditAccessLevel> {
    form_receipt::<EditAccessLevel>(form, EDITOR, AccessLevel::Edit)
}

fn view(form: FormId) -> EntityAccessReceipt<ViewAccessLevel> {
    form_receipt::<ViewAccessLevel>(form, VIEWER, AccessLevel::View)
}

#[tokio::test]
async fn which_name_a_new_form_goes_by_is_recorded_from_where_it_was_created() {
    let world = world();
    seed_party(&world);
    let (standalone, database) = create_standalone(&world).await;
    let attached = create_attached(&world, PARTY_DATABASE, PARTY_TABLE).await;

    assert_eq!(
        world.lock().unwrap().database(database).name,
        "Offsite RSVP"
    );
    let table = world.lock().unwrap().database(database).tables[0].id;
    let managed = stored(&world, standalone).form;
    assert_eq!(
        stored(&world, standalone),
        StoredForm {
            form: Form {
                id: standalone,
                name: "Offsite RSVP".into(),
                description: "".into(),
                owner_id: OWNER.into(),
                database_id: database,
                table_id: table,
                submitted_column_id: managed.submitted_column_id,
                respondent_column_id: managed.respondent_column_id,
                audience: Audience::Members,
                tally_visible: false,
                status: FormStatus::Open,
                closes_at: None,
                confirmation_message: "".into(),
                branding: FormBranding::default(),
                created_at: start_of_tests(),
                updated_at: start_of_tests(),
                project_id: None,
                is_hidden_in_drive: false,
                responses_visible: false,
                anonymous: false,
            },
            trashed_at: None,
            name_follows_database: true,
        }
    );
    assert!(!stored(&world, attached).name_follows_database);
}

#[tokio::test]
async fn renaming_a_form_that_created_its_database_renames_the_database() {
    let world = world();
    let (form, database) = create_standalone(&world).await;
    let renamed_at = Utc.with_ymd_and_hms(2026, 9, 2, 9, 0, 0).unwrap();
    world.lock().unwrap().now = renamed_at;
    let forms = service(&world);

    let renamed = forms
        .rename_form(edit(form), " Q4 offsite ".into())
        .await
        .unwrap();

    assert_eq!(renamed.name, "Q4 offsite");
    assert_eq!(renamed.updated_at, renamed_at);
    {
        let world_now = world.lock().unwrap();
        assert_eq!(world_now.database(database).name, "Q4 offsite");
        // The database's name is the form's: nothing writes a second copy.
        let shadow = world_now
            .forms
            .iter()
            .find(|stored| stored.form.id == form)
            .unwrap();
        assert_eq!(shadow.form.name, "Offsite RSVP");
        assert_eq!(shadow.form.updated_at, renamed_at);
        // The databases domain renamed it under the editor's own auth, at the
        // Edit a form's editors hold on its database.
        let [rename] = world_now.database_renames.as_slice() else {
            panic!("one database rename: {:?}", world_now.database_renames);
        };
        assert_eq!(rename.database, database);
        assert_eq!(rename.name, "Q4 offsite");
        assert_eq!(rename.level, Some(AccessLevel::Edit));
        assert!(
            matches!(&rename.auth, EntityAccessAuth::Authenticated(user) if user.as_ref() == EDITOR),
            "{:?}",
            rename.auth
        );
        assert_eq!(world_now.form_pings, vec![form]);
        assert!(
            world_now
                .event_types()
                .contains(&"form.renamed".to_string()),
            "{:?}",
            world_now.event_types()
        );
    }

    assert_eq!(
        forms.get_form(view(form)).await.unwrap().form.name,
        "Q4 offsite"
    );
}

#[tokio::test]
async fn a_bot_renaming_a_standalone_form_renames_its_database_as_itself() {
    let world = world();
    let (form, _) = create_standalone(&world).await;
    let bot = BotId::new_from_uuid(Uuid::from_u128(0xb07));
    let receipt = EntityAccessReceipt::<EditAccessLevel>::try_new_bot(
        bot.into_storage_id(),
        BotReceiptScope::User {
            acting_user: user(EDITOR),
        },
        Entity {
            entity_id: form.to_string(),
            entity_type: EntityType::Form,
        },
        EntityPermission::AccessLevel {
            access_level: AccessLevel::Edit,
        },
    )
    .unwrap();

    service(&world)
        .rename_form(receipt, "Bot named".into())
        .await
        .unwrap();

    let world = world.lock().unwrap();
    let [rename] = world.database_renames.as_slice() else {
        panic!("one database rename");
    };
    assert!(
        matches!(
            &rename.auth,
            EntityAccessAuth::Bot(auth)
                if auth.bot_id() == bot
                    && auth.scope().acting_user_id().map(|user| user.as_ref()) == Some(EDITOR)
        ),
        "{:?}",
        rename.auth
    );
}

#[tokio::test]
async fn renaming_takes_a_receipt_for_the_form_itself() {
    let world = world();
    let (form, database) = create_standalone(&world).await;
    let refused = service(&world)
        .rename_form(
            database_receipt::<EditAccessLevel>(database, OWNER, AccessLevel::Owner),
            "Through the database".into(),
        )
        .await;
    assert!(matches!(refused, Err(FormError::NotFound)), "{refused:?}");
    let world = world.lock().unwrap();
    assert!(world.database_renames.is_empty());
    assert_eq!(world.database(database).name, "Offsite RSVP");
    assert_eq!(
        world
            .forms
            .iter()
            .find(|stored| stored.form.id == form)
            .unwrap()
            .form
            .name,
        "Offsite RSVP"
    );
}

#[tokio::test]
async fn renaming_the_database_renames_its_form_wherever_the_form_is_read() {
    let world = world();
    let (form, database) = create_standalone(&world).await;
    let table = TableId::new();
    world
        .lock()
        .unwrap()
        .database_mut(database)
        .tables
        .push(FakeTable {
            id: table,
            name: "Guests".into(),
            version: 1,
            columns: vec![FakeColumn {
                id: ColumnId::new(),
                name: "Name".into(),
                kind: ColumnKind::Text,
                options: vec![],
            }],
            rows: vec![],
        });
    let attached = create_attached(&world, database, table).await;
    {
        let mut world = world.lock().unwrap();
        world.database_mut(database).name = "Renamed in the grid".into();
        world.form_grants.insert(
            OWNER.into(),
            vec![(form, AccessLevel::Owner), (attached, AccessLevel::Owner)],
        );
    }
    let forms = service(&world);

    assert_eq!(
        forms.get_form(view(form)).await.unwrap().form.name,
        "Renamed in the grid"
    );
    let reads_before_listing = world.lock().unwrap().database_metadata_reads;
    let listed = forms.accessible_forms(viewer(OWNER)).await.unwrap();
    let names: Vec<(FormId, String, FormAccess)> = listed
        .into_iter()
        .map(|ListedForm { form, access }| (form.id, form.name, access))
        .collect();
    assert_eq!(names.len(), 2);
    assert!(names.contains(&(form, "Renamed in the grid".into(), FormAccess::Owner)));
    assert!(names.contains(&(attached, "Party RSVP".into(), FormAccess::Owner)));
    // One read of the database names every form that follows it.
    assert_eq!(
        world.lock().unwrap().database_metadata_reads,
        reads_before_listing + 1
    );

    let over_database = forms
        .forms_for_database(database_receipt::<ViewAccessLevel>(
            database,
            OWNER,
            AccessLevel::Owner,
        ))
        .await
        .unwrap();
    assert_eq!(
        over_database
            .iter()
            .map(|form| (form.id, form.name.as_str()))
            .collect::<Vec<_>>(),
        vec![(form, "Renamed in the grid"), (attached, "Party RSVP")]
    );

    let updated = forms
        .update_form(
            edit(form),
            UpdateForm {
                description: Some("Tell us by Friday.".into()),
                ..UpdateForm::default()
            },
        )
        .await
        .unwrap();
    assert_eq!(updated.name, "Renamed in the grid");
    let layout = forms.get_form(view(form)).await.unwrap();
    let put = forms
        .put_layout(
            edit(form),
            FormLayout {
                sections: vec![FormSection::Questions {
                    id: match &layout.sections[0] {
                        crate::domain::models::FormSectionDetail::Questions { id, .. } => *id,
                        _ => panic!("one section of questions"),
                    },
                    title: "".into(),
                    description: "".into(),
                    questions: vec![],
                    show_when: None,
                }],
            },
        )
        .await
        .unwrap();
    assert_eq!(put.detail.form.name, "Renamed in the grid");
}

#[tokio::test]
async fn a_form_over_an_existing_table_keeps_a_name_of_its_own() {
    let world = world();
    seed_party(&world);
    let form = create_attached(&world, PARTY_DATABASE, PARTY_TABLE).await;
    let forms = service(&world);

    let renamed = forms
        .rename_form(edit(form), "Guest list".into())
        .await
        .unwrap();
    assert_eq!(renamed.name, "Guest list");
    {
        let world = world.lock().unwrap();
        assert_eq!(world.database(PARTY_DATABASE).name, "Party");
        assert!(world.database_renames.is_empty());
    }

    world.lock().unwrap().database_mut(PARTY_DATABASE).name = "Celebration".into();
    assert_eq!(
        forms.get_form(view(form)).await.unwrap().form.name,
        "Guest list"
    );
}

#[tokio::test]
async fn a_refused_database_rename_leaves_the_form_as_it_was() {
    let world = world();
    let (form, database) = create_standalone(&world).await;
    let before = stored(&world, form);
    {
        let mut world = world.lock().unwrap();
        world.now = Utc.with_ymd_and_hms(2026, 9, 2, 9, 0, 0).unwrap();
        world.refuse_next_database_rename = Some(DatabaseError::Unauthorized);
        world.events.clear();
    }
    let forms = service(&world);

    let refused = forms.rename_form(edit(form), "Q4 offsite".into()).await;

    assert!(
        matches!(
            refused,
            Err(FormError::Database(DatabaseError::Unauthorized))
        ),
        "{refused:?}"
    );
    assert_eq!(stored(&world, form), before);
    {
        let world = world.lock().unwrap();
        assert_eq!(world.database(database).name, "Offsite RSVP");
        assert!(world.form_pings.is_empty());
        assert!(world.events.is_empty());
    }
    assert_eq!(
        forms.get_form(view(form)).await.unwrap().form.name,
        "Offsite RSVP"
    );
}

#[tokio::test]
async fn a_form_whose_database_is_in_the_trash_cannot_be_renamed() {
    let world = world();
    let (form, database) = create_standalone(&world).await;
    let before = stored(&world, form);
    world.lock().unwrap().database_mut(database).trashed = true;

    let refused = service(&world)
        .rename_form(edit(form), "Q4 offsite".into())
        .await;

    assert!(matches!(refused, Err(FormError::TableGone)), "{refused:?}");
    assert_eq!(stored(&world, form), before);
    assert_eq!(
        world.lock().unwrap().database(database).name,
        "Offsite RSVP"
    );
}

#[tokio::test]
async fn a_form_named_by_a_trashed_database_still_reads_its_name() {
    let world = world();
    let (form, database) = create_standalone(&world).await;
    {
        let mut world = world.lock().unwrap();
        let trashed = world.database_mut(database);
        trashed.name = "Archived offsite".into();
        trashed.trashed = true;
        world
            .form_grants
            .insert(OWNER.into(), vec![(form, AccessLevel::Owner)]);
    }
    let forms = service(&world);

    let detail = forms.get_form(view(form)).await.unwrap();
    assert_eq!(detail.form.name, "Archived offsite");
    assert!(detail.table_gone);
    assert_eq!(
        forms.accessible_forms(viewer(OWNER)).await.unwrap()[0]
            .form
            .name,
        "Archived offsite"
    );
}

#[tokio::test]
async fn a_failed_read_of_the_databases_name_fails_the_read_instead_of_falling_back() {
    let world = world();
    seed_party(&world);
    let (form, database) = create_standalone(&world).await;
    let attached = create_attached(&world, PARTY_DATABASE, PARTY_TABLE).await;
    {
        let mut world = world.lock().unwrap();
        world.fail_database_metadata_reads = true;
        world
            .form_grants
            .insert(OWNER.into(), vec![(form, AccessLevel::Owner)]);
    }
    let forms = service(&world);

    let read = forms.get_form(view(form)).await;
    assert!(matches!(read, Err(FormError::Database(_))), "{read:?}");
    let listed = forms.accessible_forms(viewer(OWNER)).await;
    assert!(matches!(listed, Err(FormError::Database(_))), "{listed:?}");
    let over_database = forms
        .forms_for_database(database_receipt::<ViewAccessLevel>(
            database,
            OWNER,
            AccessLevel::Owner,
        ))
        .await;
    assert!(
        matches!(over_database, Err(FormError::Database(_))),
        "{over_database:?}"
    );
    let updated = forms
        .update_form(
            edit(form),
            UpdateForm {
                description: Some("Tell us by Friday.".into()),
                ..UpdateForm::default()
            },
        )
        .await;
    assert!(
        matches!(updated, Err(FormError::Database(_))),
        "{updated:?}"
    );

    // A form with a name of its own reads no database name.
    assert_eq!(
        forms.get_form(view(attached)).await.unwrap().form.name,
        "Party RSVP"
    );
}

#[tokio::test]
async fn a_form_outliving_its_database_fails_loudly() {
    let world = world();
    let (form, database) = create_standalone(&world).await;
    world
        .lock()
        .unwrap()
        .databases
        .retain(|stored| stored.id != database);

    let read = service(&world).get_form(view(form)).await;

    assert!(
        matches!(read, Err(FormError::DatabaseContract(_))),
        "{read:?}"
    );
}