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.

21.5 KB
Raw Blame
//! A respondent's own response and its edits, and what editors and poll
//! voters read: the summary and the tally.

use std::collections::BTreeMap;

use entity_access::domain::models::{EditAccessLevel, ViewAccessLevel};
use models_databases::{
    CellValue, CellWrite, DatabaseOp, EntityKind, EntityRef, OptionRef, RowChange, RowChanges,
    RowId, RowsChange,
};

use super::*;
use crate::domain::models::{
    Answer, FormError, FormResponse, FormTally, MyResponse, QuestionTally, ResponseStatus,
    ResponseSummary, SectionCount, Submission, SubmissionOutcome, TallyBucket, TallyValue,
};
use crate::domain::ports::FormsService;

fn answers(team: OptionId, diet: Option<&str>) -> Vec<Answer> {
    let mut answers = vec![
        Answer {
            question: TEAM_QUESTION,
            value: CellValue::Options(vec![OptionRef::Id(team)]),
        },
        Answer {
            question: START_QUESTION,
            value: CellValue::Date(Utc.with_ymd_and_hms(2026, 8, 17, 0, 0, 0).unwrap()),
        },
    ];
    if let Some(diet) = diet {
        answers.push(Answer {
            question: DIET_QUESTION,
            value: CellValue::Text(diet.into()),
        });
    }
    answers
}

async fn respond(forms: &Service, user: &'static str, answers: Vec<Answer>) -> SubmissionOutcome {
    forms
        .submit_response(
            form_receipt::<ViewAccessLevel>(RSVP_FORM, user, AccessLevel::View),
            Submission { answers },
        )
        .await
        .unwrap()
}

fn submitted(outcome: SubmissionOutcome) -> (crate::domain::models::FormResponseId, RowId) {
    let SubmissionOutcome::Submitted { response, row, .. } = outcome else {
        panic!("saved, not {outcome:?}");
    };
    (response, row)
}

#[tokio::test]
async fn a_respondent_reads_their_response_back_from_the_row_as_it_is_now() {
    let world = world();
    seed_rsvp(&world, Audience::Members);
    let forms = service(&world);
    let (response, row) =
        submitted(respond(&forms, VIEWER, answers(EMPLOYEE, Some("Vegan"))).await);

    // An editor fixes the diet in the grid; the respondent sees the fix.
    world.lock().unwrap().database_mut(RSVP_DATABASE).tables[0].rows[0]
        .1
        .insert(DIET, CellValue::Text("Vegetarian".into()));

    let mine = forms
        .my_response(form_receipt::<ViewAccessLevel>(
            RSVP_FORM,
            VIEWER,
            AccessLevel::View,
        ))
        .await
        .unwrap();
    assert_eq!(
        mine,
        MyResponse::Saved {
            response: Box::new(FormResponse {
                id: response,
                form_id: RSVP_FORM,
                status: ResponseStatus::Submitted,
                stopped_at_section: None,
                row: Some(row),
                submitted_at: start_of_tests(),
                updated_at: start_of_tests(),
            }),
            answers: vec![
                Answer {
                    question: TEAM_QUESTION,
                    value: CellValue::Options(vec![OptionRef::Id(EMPLOYEE)]),
                },
                Answer {
                    question: START_QUESTION,
                    value: CellValue::Date(Utc.with_ymd_and_hms(2026, 8, 17, 0, 0, 0).unwrap()),
                },
                Answer {
                    question: DIET_QUESTION,
                    value: CellValue::Text("Vegetarian".into()),
                },
            ],
            booking: None,
        }
    );
}

#[tokio::test]
async fn reading_ones_response_needs_a_signed_in_respondent_with_one() {
    let world = world();
    seed_rsvp(&world, Audience::Public);
    let forms = service(&world);
    assert!(matches!(
        forms
            .my_response(anonymous_receipt::<ViewAccessLevel>(RSVP_FORM))
            .await,
        Err(FormError::SignInRequired)
    ));
    assert!(matches!(
        forms
            .my_response(form_receipt::<ViewAccessLevel>(
                RSVP_FORM,
                VIEWER,
                AccessLevel::View
            ))
            .await,
        Err(FormError::NoResponse)
    ));
}

#[tokio::test]
async fn a_response_whose_row_was_deleted_reads_with_no_answers() {
    let world = world();
    seed_rsvp(&world, Audience::Members);
    let forms = service(&world);
    respond(&forms, VIEWER, answers(EMPLOYEE, None)).await;
    world.lock().unwrap().database_mut(RSVP_DATABASE).tables[0]
        .rows
        .clear();
    let mine = forms
        .my_response(form_receipt::<ViewAccessLevel>(
            RSVP_FORM,
            VIEWER,
            AccessLevel::View,
        ))
        .await
        .unwrap();
    let MyResponse::Saved { answers, .. } = mine else {
        panic!("a saved response");
    };
    assert_eq!(answers, vec![]);
}

#[tokio::test]
async fn an_edit_rewrites_every_question_of_the_row_and_clears_dropped_answers() {
    let world = world();
    seed_rsvp(&world, Audience::Members);
    let forms = service(&world);
    let (response, row) =
        submitted(respond(&forms, VIEWER, answers(EMPLOYEE, Some("Vegan"))).await);
    world.lock().unwrap().now = Utc.with_ymd_and_hms(2026, 9, 3, 8, 0, 0).unwrap();

    let edited = forms
        .edit_my_response(
            form_receipt::<ViewAccessLevel>(RSVP_FORM, VIEWER, AccessLevel::View),
            Submission {
                answers: vec![
                    Answer {
                        question: TEAM_QUESTION,
                        value: CellValue::Options(vec![OptionRef::Id(EMPLOYEE)]),
                    },
                    Answer {
                        question: START_QUESTION,
                        value: CellValue::Date(Utc.with_ymd_and_hms(2026, 8, 18, 0, 0, 0).unwrap()),
                    },
                    Answer {
                        question: PLUS_ONE_QUESTION,
                        value: CellValue::Boolean(true),
                    },
                ],
            },
        )
        .await
        .unwrap();
    assert_eq!(
        edited,
        SubmissionOutcome::Submitted {
            response,
            row,
            booking: None,
        }
    );

    let world = world.lock().unwrap();
    assert_eq!(
        world.batches[1],
        RecordedBatch {
            database: RSVP_DATABASE,
            internal: true,
            viewer: VIEWER.into(),
            ops: vec![DatabaseOp::Rows {
                table: RSVP_TABLE,
                change: RowsChange::Update {
                    changes: RowChanges::PerRow {
                        rows: vec![RowChange {
                            row,
                            cells: vec![
                                CellWrite {
                                    column: TEAM,
                                    value: CellValue::Options(vec![OptionRef::Id(EMPLOYEE)]),
                                },
                                CellWrite {
                                    column: START_DATE,
                                    value: CellValue::Date(
                                        Utc.with_ymd_and_hms(2026, 8, 18, 0, 0, 0).unwrap()
                                    ),
                                },
                                CellWrite {
                                    column: DIET,
                                    value: CellValue::Clear,
                                },
                                CellWrite {
                                    column: PLUS_ONE,
                                    value: CellValue::Boolean(true),
                                },
                            ],
                        }],
                    },
                },
            }],
        }
    );
    assert_eq!(
        world.ledger[0].response.updated_at,
        Utc.with_ymd_and_hms(2026, 9, 3, 8, 0, 0).unwrap()
    );
    assert_eq!(world.ledger[0].response.submitted_at, start_of_tests());
    // The managed cells keep the original submission.
    let (_, cells) = &world
        .database(RSVP_DATABASE)
        .table(RSVP_TABLE)
        .unwrap()
        .rows[0];
    assert_eq!(
        cells.get(&SUBMITTED),
        Some(&CellValue::Date(start_of_tests()))
    );
    assert_eq!(cells.get(&DIET), None);
}

#[tokio::test]
async fn an_edit_of_a_response_whose_row_was_deleted_writes_a_new_row_and_repoints_it() {
    let world = world();
    seed_rsvp(&world, Audience::Members);
    let forms = service(&world);
    let (response, _) = submitted(respond(&forms, VIEWER, answers(EMPLOYEE, None)).await);
    {
        let mut world = world.lock().unwrap();
        world.database_mut(RSVP_DATABASE).tables[0].rows.clear();
        // The row's foreign key nulls the entry's row.
        world.ledger[0].response.row = None;
        world.now = Utc.with_ymd_and_hms(2026, 9, 4, 8, 0, 0).unwrap();
    }
    let edited = forms
        .edit_my_response(
            form_receipt::<ViewAccessLevel>(RSVP_FORM, VIEWER, AccessLevel::View),
            Submission {
                answers: answers(EMPLOYEE, Some("Vegan")),
            },
        )
        .await
        .unwrap();
    let SubmissionOutcome::Submitted {
        response: edited_response,
        row,
        ..
    } = edited
    else {
        panic!("saved");
    };
    assert_eq!(edited_response, response);
    let world = world.lock().unwrap();
    assert_eq!(world.ledger[0].response.row, Some(row));
    assert_eq!(
        world
            .database(RSVP_DATABASE)
            .table(RSVP_TABLE)
            .unwrap()
            .rows,
        vec![(
            row,
            BTreeMap::from([
                (TEAM, CellValue::Options(vec![OptionRef::Id(EMPLOYEE)])),
                (
                    START_DATE,
                    CellValue::Date(Utc.with_ymd_and_hms(2026, 8, 17, 0, 0, 0).unwrap())
                ),
                (DIET, CellValue::Text("Vegan".into())),
                (SUBMITTED, CellValue::Date(start_of_tests())),
                (
                    RESPONDENT,
                    CellValue::Entities(vec![EntityRef {
                        entity_type: EntityKind::User,
                        entity_id: VIEWER.into(),
                    }])
                ),
            ])
        )]
    );
}

#[tokio::test]
async fn an_edit_stopped_by_a_gate_leaves_the_saved_response_alone() {
    let world = world();
    seed_rsvp(&world, Audience::Members);
    let forms = service(&world);
    respond(&forms, VIEWER, answers(EMPLOYEE, None)).await;
    let before = world.lock().unwrap().database(RSVP_DATABASE).clone();
    let stopped = forms
        .edit_my_response(
            form_receipt::<ViewAccessLevel>(RSVP_FORM, VIEWER, AccessLevel::View),
            Submission {
                answers: answers(CONTRACTOR, None),
            },
        )
        .await
        .unwrap();
    assert_eq!(
        stopped,
        SubmissionOutcome::Stopped {
            section: ELIGIBILITY,
            message: GATE_MESSAGE.into(),
        }
    );
    let world = world.lock().unwrap();
    assert_eq!(world.database(RSVP_DATABASE), &before);
    assert_eq!(world.batches.len(), 1);
    assert_eq!(world.ledger[0].response.status, ResponseStatus::Submitted);
}

#[tokio::test]
async fn an_edit_needs_an_open_form_a_signed_in_respondent_and_a_saved_response() {
    let world = world();
    seed_rsvp(&world, Audience::Public);
    let forms = service(&world);
    let edit = |receipt| {
        forms.edit_my_response(
            receipt,
            Submission {
                answers: answers(EMPLOYEE, None),
            },
        )
    };
    assert!(matches!(
        edit(anonymous_receipt::<ViewAccessLevel>(RSVP_FORM)).await,
        Err(FormError::SignInRequired)
    ));
    assert!(matches!(
        edit(form_receipt::<ViewAccessLevel>(
            RSVP_FORM,
            VIEWER,
            AccessLevel::View
        ))
        .await,
        Err(FormError::NoResponse)
    ));

    // A stop is not a saved response.
    respond(&forms, VIEWER, answers(CONTRACTOR, None)).await;
    assert!(matches!(
        edit(form_receipt::<ViewAccessLevel>(
            RSVP_FORM,
            VIEWER,
            AccessLevel::View
        ))
        .await,
        Err(FormError::NoResponse)
    ));

    respond(&forms, EDITOR, answers(EMPLOYEE, None)).await;
    world.lock().unwrap().forms[0].form.status = FormStatus::Closed;
    assert!(matches!(
        edit(form_receipt::<ViewAccessLevel>(
            RSVP_FORM,
            EDITOR,
            AccessLevel::View
        ))
        .await,
        Err(FormError::Closed)
    ));
}

#[tokio::test]
async fn the_summary_counts_the_ledger_by_gate_and_the_tables_rows() {
    let world = world();
    seed_rsvp(&world, Audience::Public);
    let forms = service(&world);
    respond(&forms, VIEWER, answers(EMPLOYEE, None)).await;
    respond(&forms, EDITOR, answers(CONTRACTOR, None)).await;
    respond(&forms, STRANGER, answers(CONTRACTOR, None)).await;
    forms
        .submit_response(
            anonymous_receipt::<ViewAccessLevel>(RSVP_FORM),
            Submission {
                answers: answers(EMPLOYEE, None),
            },
        )
        .await
        .unwrap();
    // A row the grid added, not a response.
    world.lock().unwrap().database_mut(RSVP_DATABASE).tables[0]
        .rows
        .push((RowId::new(), BTreeMap::new()));

    let summary = forms
        .response_summary(form_receipt::<EditAccessLevel>(
            RSVP_FORM,
            EDITOR,
            AccessLevel::Edit,
        ))
        .await
        .unwrap();
    assert_eq!(
        summary,
        ResponseSummary {
            submitted: 2,
            stopped: 2,
            stopped_by_section: vec![SectionCount {
                section: ELIGIBILITY,
                count: 2,
            }],
            rows: 3,
        }
    );
}

#[tokio::test]
async fn the_tally_counts_every_option_and_checkbox_in_layout_order() {
    let world = world();
    seed_rsvp(&world, Audience::Members);
    let forms = service(&world);
    respond(&forms, VIEWER, answers(EMPLOYEE, None)).await;
    // Voters list in submission order, so the second response lands later.
    world.lock().unwrap().now = Utc.with_ymd_and_hms(2026, 9, 3, 8, 0, 0).unwrap();
    let mut with_plus_one = answers(EMPLOYEE, None);
    with_plus_one.push(Answer {
        question: PLUS_ONE_QUESTION,
        value: CellValue::Boolean(true),
    });
    respond(&forms, EDITOR, with_plus_one).await;

    let tally = forms
        .tally(form_receipt::<ViewAccessLevel>(
            RSVP_FORM,
            OWNER,
            AccessLevel::Owner,
        ))
        .await
        .unwrap();
    assert_eq!(
        tally,
        FormTally {
            questions: vec![
                QuestionTally {
                    question: TEAM_QUESTION,
                    responses: 2,
                    buckets: vec![
                        TallyBucket {
                            value: TallyValue::Option { option: EMPLOYEE },
                            count: 2,
                            voters: Some(vec![VIEWER.to_string(), EDITOR.to_string()]),
                        },
                        TallyBucket {
                            value: TallyValue::Option { option: CONTRACTOR },
                            count: 0,
                            voters: Some(Vec::new()),
                        },
                    ],
                },
                QuestionTally {
                    question: PLUS_ONE_QUESTION,
                    responses: 1,
                    buckets: vec![
                        TallyBucket {
                            value: TallyValue::Checkbox { checked: true },
                            count: 1,
                            voters: Some(vec![EDITOR.to_string()]),
                        },
                        TallyBucket {
                            value: TallyValue::Checkbox { checked: false },
                            count: 0,
                            voters: Some(Vec::new()),
                        },
                    ],
                },
            ],
        }
    );
}

#[tokio::test]
async fn respondents_read_the_tally_only_when_the_owner_shows_it() {
    let world = world();
    seed_rsvp(&world, Audience::Public);
    let forms = service(&world);
    assert!(matches!(
        forms
            .tally(form_receipt::<ViewAccessLevel>(
                RSVP_FORM,
                VIEWER,
                AccessLevel::View
            ))
            .await,
        Err(FormError::TallyHidden)
    ));
    assert!(matches!(
        forms
            .tally(anonymous_receipt::<ViewAccessLevel>(RSVP_FORM))
            .await,
        Err(FormError::TallyHidden)
    ));
    forms
        .tally(form_receipt::<ViewAccessLevel>(
            RSVP_FORM,
            EDITOR,
            AccessLevel::Edit,
        ))
        .await
        .unwrap();

    world.lock().unwrap().forms[0].form.tally_visible = true;
    forms
        .tally(anonymous_receipt::<ViewAccessLevel>(RSVP_FORM))
        .await
        .unwrap();
}

#[tokio::test]
async fn respondents_see_who_voted_only_when_the_responses_are_shared() {
    let world = world();
    seed_rsvp(&world, Audience::Members);
    world.lock().unwrap().forms[0].form.tally_visible = true;
    let forms = service(&world);
    respond(&forms, VIEWER, answers(EMPLOYEE, None)).await;
    let voters_seen_by_viewer = || async {
        forms
            .tally(form_receipt::<ViewAccessLevel>(
                RSVP_FORM,
                VIEWER,
                AccessLevel::View,
            ))
            .await
            .unwrap()
            .questions[0]
            .buckets[0]
            .voters
            .clone()
    };

    assert_eq!(voters_seen_by_viewer().await, None);

    world.lock().unwrap().forms[0].form.responses_visible = true;
    assert_eq!(
        voters_seen_by_viewer().await,
        Some(vec![VIEWER.to_string()])
    );
}

#[tokio::test]
async fn nobody_sees_who_voted_on_an_anonymous_form_not_even_its_owner() {
    let world = world();
    seed_rsvp(&world, Audience::Members);
    {
        let mut world = world.lock().unwrap();
        world.forms[0].form.anonymous = true;
        world.forms[0].form.responses_visible = true;
    }
    let forms = service(&world);
    respond(&forms, VIEWER, answers(EMPLOYEE, None)).await;

    let tally = forms
        .tally(form_receipt::<ViewAccessLevel>(
            RSVP_FORM,
            OWNER,
            AccessLevel::Owner,
        ))
        .await
        .unwrap();
    assert_eq!(tally.questions[0].buckets[0].count, 1);
    assert_eq!(tally.questions[0].buckets[0].voters, None);
}

#[tokio::test]
async fn rewriting_a_lost_row_skips_managed_columns_retyped_in_the_grid() {
    let world = world();
    seed_rsvp(&world, Audience::Members);
    let forms = service(&world);
    let (response, _) = submitted(respond(&forms, VIEWER, answers(EMPLOYEE, None)).await);
    {
        let mut world = world.lock().unwrap();
        let table = &mut world.database_mut(RSVP_DATABASE).tables[0];
        table.rows.clear();
        for column in &mut table.columns {
            if column.id == SUBMITTED {
                column.kind = ColumnKind::Number;
            }
            if column.id == RESPONDENT {
                column.kind = ColumnKind::Entity {
                    target: EntityKind::User,
                    multi: true,
                };
            }
        }
        world.ledger[0].response.row = None;
    }
    let edited = forms
        .edit_my_response(
            form_receipt::<ViewAccessLevel>(RSVP_FORM, VIEWER, AccessLevel::View),
            Submission {
                answers: answers(EMPLOYEE, None),
            },
        )
        .await
        .unwrap();
    let SubmissionOutcome::Submitted {
        response: edited_response,
        row,
        ..
    } = edited
    else {
        panic!("saved, not {edited:?}");
    };
    assert_eq!(edited_response, response);
    let world = world.lock().unwrap();
    let cells = &world
        .database(RSVP_DATABASE)
        .table(RSVP_TABLE)
        .unwrap()
        .rows[0]
        .1;
    assert!(!cells.contains_key(&SUBMITTED));
    assert!(!cells.contains_key(&RESPONDENT));
    assert_eq!(world.ledger[0].response.row, Some(row));
}

#[tokio::test]
async fn a_database_trashed_while_reading_ones_response_reads_as_the_receipt_without_answers() {
    let world = world();
    seed_rsvp(&world, Audience::Members);
    let forms = service(&world);
    let (response, row) = submitted(respond(&forms, VIEWER, answers(EMPLOYEE, None)).await);
    world.lock().unwrap().grid_change_before_next_cell_read =
        Some(GridChange::TrashDatabase(RSVP_DATABASE));

    let mine = forms
        .my_response(form_receipt::<ViewAccessLevel>(
            RSVP_FORM,
            VIEWER,
            AccessLevel::View,
        ))
        .await
        .unwrap();

    let MyResponse::Saved {
        response: entry,
        answers,
        ..
    } = mine
    else {
        panic!("a saved response");
    };
    assert_eq!(entry.id, response);
    assert_eq!(entry.row, Some(row));
    assert_eq!(answers, vec![]);
}

#[tokio::test]
async fn a_question_whose_column_is_deleted_while_tallying_drops_out_of_the_tally() {
    let world = world();
    seed_rsvp(&world, Audience::Members);
    let forms = service(&world);
    respond(&forms, VIEWER, answers(EMPLOYEE, None)).await;
    // Team is tallied first; it goes between the table read and its cells.
    world.lock().unwrap().grid_change_before_next_cell_read = Some(GridChange::DeleteColumn(TEAM));

    let tally = forms
        .tally(form_receipt::<ViewAccessLevel>(
            RSVP_FORM,
            OWNER,
            AccessLevel::Owner,
        ))
        .await
        .unwrap();

    assert_eq!(
        tally
            .questions
            .iter()
            .map(|question| question.question)
            .collect::<Vec<_>>(),
        vec![PLUS_ONE_QUESTION]
    );
}