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.

28.6 KB
Raw Blame
//! In-memory fakes for every port, over one shared world the tests inspect.

pub(crate) mod databases;
mod drafts;
pub(crate) use drafts::FakeDrafts;

use std::collections::HashMap;
use std::sync::{Arc, Mutex};

use chrono::{DateTime, Utc};
use entity_access::domain::models::AccessLevel;
use macro_event_broker::{EventBrokerError, MacroEvent, MacroEventBroker};
use macro_user_id::user_id::MacroUserIdStr;
use models_permissions::share_permission::access_level::AccessLevel as ShareAccessLevel;
use models_permissions::share_permission::channel_share_permission::{
    ChannelSharePermission, UpdateChannelSharePermission, UpdateOperation,
};

use crate::domain::models::{
    Audience, ColumnId, DatabaseId, ForbiddenWidget, Form, FormId, FormLayout, FormResponse,
    FormResponseId, FormSection, FormSectionId, FormUpdate, LayoutReplacement, RecordedResponse,
    ResponseCounts, ResponseStatus, RowId, StoredForm, StoredImageFile, UpdateForm, Widget,
};
use crate::domain::ports::{
    Clock, FormAccessDirectory, FormEventPublisher, FormImageFiles, FormsRepo,
};
use crate::domain::sharing::FormSharingRepo;

pub(crate) use self::databases::{
    FakeColumn, FakeDatabase, FakeDatabases, FakeTable, GridChange, RecordedBatch,
    RecordedDatabaseRename,
};

#[derive(Debug, thiserror::Error)]
#[error("fake failure")]
pub(crate) struct FakeError;

/// One ledger entry, with who it belongs to.
#[derive(Debug, Clone, PartialEq)]
pub(crate) struct LedgerEntry {
    pub(crate) response: FormResponse,
    pub(crate) respondent: Option<String>,
}

/// Shared mutable world the fakes read and write.
pub(crate) struct World {
    pub(crate) now: DateTime<Utc>,
    pub(crate) forms: Vec<StoredForm>,
    pub(crate) layouts: HashMap<FormId, FormLayout>,
    pub(crate) drafts: HashMap<FormId, Vec<u8>>,
    pub(crate) draft_states: HashMap<FormId, crate::domain::drafts::LayoutDraftState>,
    pub(crate) retired_drafts: Vec<FormId>,
    pub(crate) fail_drafts: bool,
    /// A human CRDT update landing between validation and the next conditional write.
    pub(crate) draft_update_before_next_write: Option<Vec<u8>>,
    /// Owner grants the repository wrote with each new form.
    pub(crate) owner_grants: Vec<(FormId, String)>,
    pub(crate) ledger: Vec<LedgerEntry>,
    /// Who has responded to each anonymous form.
    pub(crate) receipts: Vec<(FormId, String)>,
    pub(crate) channel_grants: HashMap<FormId, Vec<ChannelSharePermission>>,
    /// Every form a liveness ping named, oldest first.
    pub(crate) form_pings: Vec<FormId>,
    /// Fail every liveness ping.
    pub(crate) fail_form_pings: bool,
    /// Fail every grant lookup of the forms catalog.
    pub(crate) fail_form_grants: bool,
    /// Each user's grants on forms, as `entity_access` would answer them.
    pub(crate) form_grants: HashMap<String, Vec<(FormId, AccessLevel)>>,
    /// Fail the next ledger write, after the row is written.
    pub(crate) fail_next_ledger_write: bool,
    pub(crate) databases: Vec<FakeDatabase>,
    /// Every database the service created: its name and owner.
    pub(crate) created_databases: Vec<(String, String)>,
    /// Every database the service purged.
    pub(crate) purged_databases: Vec<DatabaseId>,
    /// Every batch the service applied, refused ones included.
    pub(crate) batches: Vec<RecordedBatch>,
    /// A concurrent change of the form's audience that commits just before
    /// the next layout write.
    pub(crate) audience_before_next_layout_write: Option<Audience>,
    /// A concurrent layout put that commits just before the next change of
    /// the form's facts.
    pub(crate) layout_before_next_update: Option<FormLayout>,
    /// A concurrent submission by this person to this form that commits
    /// its ledger entry while the next batch is being written.
    pub(crate) competing_submission: Option<(FormId, String)>,
    /// A grid change that commits just before the next cell read.
    pub(crate) grid_change_before_next_cell_read: Option<GridChange>,
    /// Refuse the next batch with this error.
    pub(crate) adopt_new_database_before_next_batch: bool,
    pub(crate) refuse_next_batch: Option<::databases::domain::models::DatabaseError>,
    /// Every database rename the service asked for, refused ones included.
    pub(crate) database_renames: Vec<RecordedDatabaseRename>,
    /// Refuse the next database rename with this error.
    pub(crate) refuse_next_database_rename: Option<::databases::domain::models::DatabaseError>,
    /// Fail every read of a database's own facts.
    pub(crate) fail_database_metadata_reads: bool,
    /// How many times the service read a database's own facts.
    pub(crate) database_metadata_reads: usize,
    /// Every `macro.forms` envelope the service handed the broker.
    pub(crate) events: Vec<serde_json::Value>,
    /// Uploaded files, by id, as static-file storage records them.
    pub(crate) image_files: HashMap<uuid::Uuid, StoredImageFile>,
}

impl World {
    pub(crate) fn new(now: DateTime<Utc>) -> Self {
        Self {
            now,
            forms: vec![],
            layouts: HashMap::new(),
            drafts: HashMap::new(),
            draft_states: HashMap::new(),
            retired_drafts: vec![],
            fail_drafts: false,
            draft_update_before_next_write: None,
            owner_grants: vec![],
            ledger: vec![],
            receipts: vec![],
            channel_grants: HashMap::new(),
            form_grants: HashMap::new(),
            form_pings: vec![],
            fail_form_pings: false,
            fail_form_grants: false,
            fail_next_ledger_write: false,
            databases: vec![],
            created_databases: vec![],
            purged_databases: vec![],
            batches: vec![],
            audience_before_next_layout_write: None,
            layout_before_next_update: None,
            competing_submission: None,
            grid_change_before_next_cell_read: None,
            adopt_new_database_before_next_batch: false,
            refuse_next_batch: None,
            database_renames: vec![],
            refuse_next_database_rename: None,
            fail_database_metadata_reads: false,
            database_metadata_reads: 0,
            events: vec![],
            image_files: HashMap::new(),
        }
    }

    /// The event types published, oldest first.
    pub(crate) fn event_types(&self) -> Vec<String> {
        self.events
            .iter()
            .map(|event| event["event_type"].as_str().unwrap_or_default().to_string())
            .collect()
    }

    pub(crate) fn database(&self, id: DatabaseId) -> &FakeDatabase {
        self.databases
            .iter()
            .find(|database| database.id == id)
            .expect("the database exists")
    }

    pub(crate) fn database_mut(&mut self, id: DatabaseId) -> &mut FakeDatabase {
        self.databases
            .iter_mut()
            .find(|database| database.id == id)
            .expect("the database exists")
    }
}

pub(crate) type Shared = Arc<Mutex<World>>;

/// The forms repository over the shared world.
#[derive(Clone)]
pub(crate) struct FakeRepo(pub(crate) Shared);

/// The grants the world holds on forms.
#[derive(Clone)]
pub(crate) struct FakeAccess(pub(crate) Shared);

impl FormAccessDirectory for FakeAccess {
    type Error = FakeError;

    async fn accessible_forms(
        &self,
        user: &MacroUserIdStr<'_>,
    ) -> Result<Vec<(FormId, AccessLevel)>, FakeError> {
        let world = self.0.lock().unwrap();
        if world.fail_form_grants {
            return Err(FakeError);
        }
        Ok(world
            .form_grants
            .get(user.as_ref())
            .cloned()
            .unwrap_or_default())
    }
}

/// The uploaded files the world holds.
#[derive(Clone)]
pub(crate) struct FakeImageFiles(pub(crate) Shared);

impl FormImageFiles for FakeImageFiles {
    type Error = FakeError;

    async fn image_file(&self, file: uuid::Uuid) -> Result<Option<StoredImageFile>, FakeError> {
        Ok(self.0.lock().unwrap().image_files.get(&file).cloned())
    }
}

/// Records each form a liveness ping named, and fails when told to.
#[derive(Clone)]
pub(crate) struct RecordingFormEvents(pub(crate) Shared);

impl FormEventPublisher for RecordingFormEvents {
    type Error = FakeError;

    async fn form_changed(&self, form: FormId) -> Result<(), FakeError> {
        let mut world = self.0.lock().unwrap();
        if world.fail_form_pings {
            return Err(FakeError);
        }
        world.form_pings.push(form);
        Ok(())
    }
}

/// The clock the world's `now` sets.
#[derive(Clone)]
pub(crate) struct FixedClock(pub(crate) Shared);

impl Clock for FixedClock {
    fn now(&self) -> DateTime<Utc> {
        self.0.lock().unwrap().now
    }
}

/// Records every event the service publishes.
#[derive(Clone)]
pub(crate) struct RecordingBroker(pub(crate) Shared);

impl MacroEventBroker for RecordingBroker {
    fn send_event<E: MacroEvent + ?Sized>(
        &self,
        event: &E,
    ) -> Result<tokio::task::JoinHandle<Result<(), EventBrokerError>>, EventBrokerError> {
        let envelope =
            serde_json::to_value(event.event()).map_err(EventBrokerError::Serialization)?;
        self.0.lock().unwrap().events.push(envelope);
        Ok(tokio::spawn(async { Ok(()) }))
    }
}

/// Every section and question id of a layout.
fn layout_ids(layout: &FormLayout) -> Vec<uuid::Uuid> {
    layout
        .sections
        .iter()
        .flat_map(|section| {
            let questions = match section {
                FormSection::Questions { questions, .. } => questions
                    .iter()
                    .map(|question| question.id.into_uuid())
                    .collect(),
                FormSection::Gate { .. } | FormSection::Booking { .. } => vec![],
            };
            std::iter::once(section.id().into_uuid()).chain(questions)
        })
        .collect()
}

/// Every widget a layout's questions name, with the question's column.
fn layout_widgets(layout: &FormLayout) -> Vec<(ColumnId, Widget)> {
    layout
        .sections
        .iter()
        .flat_map(|section| match section {
            FormSection::Questions { questions, .. } => questions
                .iter()
                .filter_map(|question| question.widget.map(|widget| (question.column, widget)))
                .collect(),
            FormSection::Gate { .. } | FormSection::Booking { .. } => vec![],
        })
        .collect()
}

fn live(world: &World, id: FormId) -> Option<usize> {
    world
        .forms
        .iter()
        .position(|stored| stored.form.id == id && stored.trashed_at.is_none())
}

fn ledger_write(world: &mut World) -> Result<(), FakeError> {
    if world.fail_next_ledger_write {
        world.fail_next_ledger_write = false;
        return Err(FakeError);
    }
    Ok(())
}

fn replace_layout_locked(
    world: &mut World,
    id: FormId,
    layout: &FormLayout,
    updated_at: DateTime<Utc>,
    required_audience: Option<Audience>,
) -> Result<LayoutReplacement, FakeError> {
    let Some(position) = live(world, id) else {
        return Ok(LayoutReplacement::FormGone);
    };
    if let Some(audience) = world.audience_before_next_layout_write.take() {
        world.forms[position].form.audience = audience;
    }
    let others: Vec<uuid::Uuid> = world
        .layouts
        .iter()
        .filter(|(form, _)| **form != id)
        .flat_map(|(_, layout)| layout_ids(layout))
        .collect();
    if let Some(taken) = layout_ids(layout)
        .into_iter()
        .find(|id| others.contains(id))
    {
        return Ok(LayoutReplacement::IdTaken(taken));
    }
    if required_audience.is_some_and(|audience| world.forms[position].form.audience != audience) {
        return Ok(LayoutReplacement::AudienceChanged);
    }
    world.forms[position].form.updated_at = updated_at;
    world.layouts.insert(id, layout.clone());
    Ok(LayoutReplacement::Replaced)
}

impl FormsRepo for FakeRepo {
    type Error = FakeError;

    async fn create_form(
        &self,
        form: &Form,
        layout: &FormLayout,
        name_follows_database: bool,
    ) -> Result<crate::domain::models::FormCreation, FakeError> {
        let mut world = self.0.lock().unwrap();
        if world
            .forms
            .iter()
            .any(|stored| stored.form.table_id == form.table_id)
        {
            return Ok(crate::domain::models::FormCreation::TableOccupied);
        }
        world.forms.push(StoredForm {
            form: form.clone(),
            trashed_at: None,
            name_follows_database,
        });
        world.layouts.insert(form.id, layout.clone());
        world.owner_grants.push((form.id, form.owner_id.clone()));
        Ok(crate::domain::models::FormCreation::Created)
    }

    async fn table_has_form(
        &self,
        table: crate::domain::models::TableId,
    ) -> Result<bool, FakeError> {
        Ok(self
            .0
            .lock()
            .unwrap()
            .forms
            .iter()
            .any(|stored| stored.form.table_id == table))
    }

    async fn form(&self, id: FormId) -> Result<Option<StoredForm>, FakeError> {
        let world = self.0.lock().unwrap();
        Ok(world
            .forms
            .iter()
            .find(|stored| stored.form.id == id)
            .cloned())
    }

    async fn forms_by_ids(&self, ids: &[FormId]) -> Result<Vec<Form>, FakeError> {
        let world = self.0.lock().unwrap();
        Ok(world
            .forms
            .iter()
            .filter(|stored| ids.contains(&stored.form.id) && stored.trashed_at.is_none())
            .map(|stored| stored.form.clone())
            .collect())
    }

    async fn forms_with_database_names(&self, ids: &[FormId]) -> Result<Vec<FormId>, FakeError> {
        let world = self.0.lock().unwrap();
        Ok(world
            .forms
            .iter()
            .filter(|stored| ids.contains(&stored.form.id) && stored.name_follows_database)
            .map(|stored| stored.form.id)
            .collect())
    }

    async fn forms_for_database(&self, database_id: DatabaseId) -> Result<Vec<Form>, FakeError> {
        let world = self.0.lock().unwrap();
        Ok(world
            .forms
            .iter()
            .filter(|stored| stored.form.database_id == database_id && stored.trashed_at.is_none())
            .map(|stored| stored.form.clone())
            .collect())
    }

    async fn layout(&self, id: FormId) -> Result<FormLayout, FakeError> {
        let world = self.0.lock().unwrap();
        Ok(world
            .layouts
            .get(&id)
            .cloned()
            .unwrap_or(FormLayout { sections: vec![] }))
    }

    async fn replace_layout(
        &self,
        id: FormId,
        layout: &FormLayout,
        updated_at: DateTime<Utc>,
        required_audience: Option<Audience>,
    ) -> Result<LayoutReplacement, FakeError> {
        let mut world = self.0.lock().unwrap();
        if world
            .draft_states
            .get(&id)
            .is_some_and(|state| state.enabled)
        {
            return Ok(LayoutReplacement::DraftRequired);
        }
        replace_layout_locked(&mut world, id, layout, updated_at, required_audience)
    }

    async fn update_form(
        &self,
        id: FormId,
        changes: &UpdateForm,
        updated_at: DateTime<Utc>,
        forbidden_widget: Option<ForbiddenWidget>,
    ) -> Result<FormUpdate, FakeError> {
        let mut world = self.0.lock().unwrap();
        let Some(position) = live(&world, id) else {
            return Ok(FormUpdate::FormGone);
        };
        if let Some(layout) = world.layout_before_next_update.take() {
            world.layouts.insert(id, layout);
        }
        if let Some(forbidden) = forbidden_widget
            && world.layouts.get(&id).is_some_and(|layout| {
                layout_widgets(layout).into_iter().any(|(column, widget)| {
                    widget == forbidden.widget && forbidden.columns.contains(&column)
                })
            })
        {
            return Ok(FormUpdate::WidgetInUse);
        }
        if changes
            .anonymous
            .is_some_and(|anonymous| anonymous != world.forms[position].form.anonymous)
            && world.ledger.iter().any(|entry| {
                entry.response.form_id == id && entry.response.status == ResponseStatus::Submitted
            })
        {
            return Ok(FormUpdate::AnonymityLocked);
        }
        let form = &mut world.forms[position].form;
        if let Some(description) = &changes.description {
            form.description = description.clone();
        }
        if let Some(message) = &changes.confirmation_message {
            form.confirmation_message = message.clone();
        }
        if let Some(audience) = changes.audience {
            form.audience = audience;
        }
        if let Some(status) = changes.status {
            form.status = status;
        }
        if let Some(closes_at) = changes.closes_at {
            form.closes_at = closes_at;
        }
        if let Some(tally_visible) = changes.tally_visible {
            form.tally_visible = tally_visible;
        }
        if let Some(responses_visible) = changes.responses_visible {
            form.responses_visible = responses_visible;
        }
        if let Some(anonymous) = changes.anonymous {
            form.anonymous = anonymous;
        }
        if let Some(logo_file_id) = changes.logo_file_id {
            form.branding.logo_file_id = logo_file_id;
        }
        if let Some(cover_file_id) = changes.cover_file_id {
            form.branding.cover_file_id = cover_file_id;
        }
        if let Some(accent_color) = &changes.accent_color {
            form.branding.accent_color = accent_color.clone();
        }
        form.updated_at = updated_at;
        Ok(FormUpdate::Updated(Box::new(form.clone())))
    }

    async fn rename_form(
        &self,
        id: FormId,
        name: &str,
        updated_at: DateTime<Utc>,
    ) -> Result<Option<Form>, FakeError> {
        let mut world = self.0.lock().unwrap();
        let Some(position) = live(&world, id) else {
            return Ok(None);
        };
        let form = &mut world.forms[position].form;
        form.name = name.to_string();
        form.updated_at = updated_at;
        Ok(Some(form.clone()))
    }

    async fn touch_form(
        &self,
        id: FormId,
        updated_at: DateTime<Utc>,
    ) -> Result<Option<Form>, FakeError> {
        let mut world = self.0.lock().unwrap();
        let Some(position) = live(&world, id) else {
            return Ok(None);
        };
        let form = &mut world.forms[position].form;
        form.updated_at = updated_at;
        Ok(Some(form.clone()))
    }

    async fn trash_form(&self, id: FormId, trashed_at: DateTime<Utc>) -> Result<bool, FakeError> {
        let mut world = self.0.lock().unwrap();
        Ok(
            match world.forms.iter_mut().find(|stored| stored.form.id == id) {
                Some(stored) => {
                    stored.trashed_at = Some(trashed_at);
                    true
                }
                None => false,
            },
        )
    }

    async fn restore_form(&self, id: FormId) -> Result<bool, FakeError> {
        let mut world = self.0.lock().unwrap();
        Ok(
            match world.forms.iter_mut().find(|stored| stored.form.id == id) {
                Some(stored) => {
                    stored.trashed_at = None;
                    true
                }
                None => false,
            },
        )
    }

    async fn move_form(&self, id: FormId, project_id: Option<&str>) -> Result<bool, FakeError> {
        let mut world = self.0.lock().unwrap();
        Ok(
            match world
                .forms
                .iter_mut()
                .find(|stored| stored.form.id == id && stored.trashed_at.is_none())
            {
                Some(stored) => {
                    stored.form.project_id = project_id.map(str::to_string);
                    true
                }
                None => false,
            },
        )
    }

    async fn delete_form(&self, id: FormId) -> Result<(), FakeError> {
        let mut world = self.0.lock().unwrap();
        world.forms.retain(|stored| stored.form.id != id);
        world.layouts.remove(&id);
        world.ledger.retain(|entry| entry.response.form_id != id);
        world.receipts.retain(|(form, _)| *form != id);
        world.owner_grants.retain(|(form, _)| *form != id);
        world.channel_grants.remove(&id);
        Ok(())
    }

    async fn response_of(
        &self,
        form: FormId,
        respondent: &MacroUserIdStr<'_>,
    ) -> Result<Option<FormResponse>, FakeError> {
        let world = self.0.lock().unwrap();
        Ok(world
            .ledger
            .iter()
            .find(|entry| {
                entry.response.form_id == form
                    && entry.respondent.as_deref() == Some(respondent.as_ref())
            })
            .map(|entry| entry.response.clone()))
    }

    async fn record_stop(
        &self,
        form: FormId,
        respondent: &MacroUserIdStr<'_>,
        section: FormSectionId,
        at: DateTime<Utc>,
    ) -> Result<(), FakeError> {
        let mut world = self.0.lock().unwrap();
        ledger_write(&mut world)?;
        let existing = world.ledger.iter_mut().find(|entry| {
            entry.response.form_id == form
                && entry.respondent.as_deref() == Some(respondent.as_ref())
        });
        match existing {
            Some(entry) if entry.response.status == ResponseStatus::Submitted => {}
            Some(entry) => {
                entry.response.stopped_at_section = Some(section);
                entry.response.updated_at = at;
            }
            None => {
                world.ledger.push(LedgerEntry {
                    response: FormResponse {
                        id: FormResponseId::new(),
                        form_id: form,
                        status: ResponseStatus::Stopped,
                        stopped_at_section: Some(section),
                        row: None,
                        submitted_at: at,
                        updated_at: at,
                    },
                    respondent: Some(respondent.to_string()),
                });
            }
        }
        Ok(())
    }

    async fn record_submission(
        &self,
        form: FormId,
        respondent: Option<&MacroUserIdStr<'_>>,
        row: RowId,
        at: DateTime<Utc>,
    ) -> Result<RecordedResponse, FakeError> {
        let mut world = self.0.lock().unwrap();
        ledger_write(&mut world)?;
        if let Some(respondent) = respondent
            && let Some(entry) = world.ledger.iter_mut().find(|entry| {
                entry.response.form_id == form
                    && entry.respondent.as_deref() == Some(respondent.as_ref())
            })
        {
            if entry.response.status == ResponseStatus::Submitted {
                return Ok(RecordedResponse::AlreadySubmitted);
            }
            entry.response = FormResponse {
                id: entry.response.id,
                form_id: form,
                status: ResponseStatus::Submitted,
                stopped_at_section: None,
                row: Some(row),
                submitted_at: at,
                updated_at: at,
            };
            return Ok(RecordedResponse::Recorded(entry.response.clone()));
        }
        let response = FormResponse {
            id: FormResponseId::new(),
            form_id: form,
            status: ResponseStatus::Submitted,
            stopped_at_section: None,
            row: Some(row),
            submitted_at: at,
            updated_at: at,
        };
        world.ledger.push(LedgerEntry {
            response: response.clone(),
            respondent: respondent.map(|respondent| respondent.to_string()),
        });
        Ok(RecordedResponse::Recorded(response))
    }

    async fn record_anonymous_submission(
        &self,
        form: FormId,
        voter: Option<&MacroUserIdStr<'_>>,
        row: RowId,
        day: DateTime<Utc>,
    ) -> Result<RecordedResponse, FakeError> {
        let mut world = self.0.lock().unwrap();
        ledger_write(&mut world)?;
        if let Some(voter) = voter {
            let receipt = (form, voter.to_string());
            if world.receipts.contains(&receipt) {
                return Ok(RecordedResponse::AlreadySubmitted);
            }
            world.receipts.push(receipt);
        }
        let response = FormResponse {
            id: FormResponseId::from_uuid(uuid::Uuid::new_v4()),
            form_id: form,
            status: ResponseStatus::Submitted,
            stopped_at_section: None,
            row: Some(row),
            submitted_at: day,
            updated_at: day,
        };
        world.ledger.push(LedgerEntry {
            response: response.clone(),
            respondent: None,
        });
        Ok(RecordedResponse::Recorded(response))
    }

    async fn holds_receipt(
        &self,
        form: FormId,
        voter: &MacroUserIdStr<'_>,
    ) -> Result<bool, FakeError> {
        let world = self.0.lock().unwrap();
        Ok(world.receipts.contains(&(form, voter.to_string())))
    }

    async fn repoint_response(
        &self,
        response: FormResponseId,
        row: RowId,
        at: DateTime<Utc>,
    ) -> Result<(), FakeError> {
        let mut world = self.0.lock().unwrap();
        ledger_write(&mut world)?;
        let entry = world
            .ledger
            .iter_mut()
            .find(|entry| entry.response.id == response)
            .ok_or(FakeError)?;
        entry.response.row = Some(row);
        entry.response.updated_at = at;
        Ok(())
    }

    async fn touch_response(
        &self,
        response: FormResponseId,
        at: DateTime<Utc>,
    ) -> Result<(), FakeError> {
        let mut world = self.0.lock().unwrap();
        if let Some(entry) = world
            .ledger
            .iter_mut()
            .find(|entry| entry.response.id == response)
        {
            entry.response.updated_at = at;
        }
        Ok(())
    }

    async fn response_counts(&self, form: FormId) -> Result<ResponseCounts, FakeError> {
        let world = self.0.lock().unwrap();
        let mut counts = ResponseCounts::default();
        let mut stopped: HashMap<FormSectionId, u64> = HashMap::new();
        for entry in world
            .ledger
            .iter()
            .filter(|entry| entry.response.form_id == form)
        {
            match (entry.response.status, entry.response.stopped_at_section) {
                (ResponseStatus::Submitted, _) => counts.submitted += 1,
                (ResponseStatus::Stopped, Some(section)) => {
                    *stopped.entry(section).or_default() += 1
                }
                (ResponseStatus::Stopped, None) => {}
            }
        }
        counts.stopped_by_section = stopped.into_iter().collect();
        Ok(counts)
    }

    async fn respondents_by_row(
        &self,
        form: FormId,
    ) -> Result<Vec<(RowId, MacroUserIdStr<'static>)>, FakeError> {
        let world = self.0.lock().unwrap();
        let mut entries: Vec<&LedgerEntry> = world
            .ledger
            .iter()
            .filter(|entry| {
                entry.response.form_id == form && entry.response.status == ResponseStatus::Submitted
            })
            .collect();
        entries.sort_by_key(|entry| (entry.response.submitted_at, entry.response.id));
        Ok(entries
            .into_iter()
            .filter_map(|entry| {
                let row = entry.response.row?;
                let respondent = MacroUserIdStr::try_from(entry.respondent.clone()?).ok()?;
                Some((row, respondent))
            })
            .collect())
    }
}

impl FormSharingRepo for FakeRepo {
    type Error = FakeError;

    async fn channel_grants(
        &self,
        form_id: FormId,
    ) -> Result<Vec<ChannelSharePermission>, FakeError> {
        let world = self.0.lock().unwrap();
        Ok(world
            .channel_grants
            .get(&form_id)
            .cloned()
            .unwrap_or_default())
    }

    async fn update_channel_grants(
        &self,
        form_id: FormId,
        grants: &[UpdateChannelSharePermission],
    ) -> Result<bool, FakeError> {
        let mut world = self.0.lock().unwrap();
        if live(&world, form_id).is_none() {
            return Ok(false);
        }
        let current = world.channel_grants.entry(form_id).or_default();
        for grant in grants {
            current.retain(|existing| existing.channel_id != grant.channel_id);
            if grant.operation != UpdateOperation::Remove {
                current.push(ChannelSharePermission {
                    channel_id: grant.channel_id.clone(),
                    access_level: grant.access_level.unwrap_or(ShareAccessLevel::View),
                });
            }
        }
        Ok(true)
    }
}