AppFlowy/frontend/rust-lib/flowy-client-sync/src/client_folder/folder_pad.rs

use crate::errors::internal_sync_error;
use crate::util::cal_diff;
use crate::{
    client_folder::builder::FolderPadBuilder,
    errors::{SyncError, SyncResult},
};
use folder_model::{AppRevision, FolderRevision, TrashRevision, ViewRevision, WorkspaceRevision};
use lib_infra::util::md5;
use lib_infra::util::move_vec_element;
use lib_ot::core::*;
use revision_model::Revision;
use serde::Deserialize;
use std::sync::Arc;

pub type FolderOperations = DeltaOperations<EmptyAttributes>;
pub type FolderOperationsBuilder = DeltaOperationBuilder<EmptyAttributes>;

#[derive(Debug, Clone, Eq, PartialEq)]
pub struct FolderPad {
    folder_rev: FolderRevision,
    operations: FolderOperations,
}

impl FolderPad {
    pub fn new(workspaces: Vec<WorkspaceRevision>, trash: Vec<TrashRevision>) -> SyncResult<Self> {
        let folder_rev = FolderRevision {
            workspaces: workspaces.into_iter().map(Arc::new).collect(),
            trash: trash.into_iter().map(Arc::new).collect(),
        };
        Self::from_folder_rev(folder_rev)
    }

    pub fn from_folder_rev(folder_rev: FolderRevision) -> SyncResult<Self> {
        let json = serde_json::to_string(&folder_rev)
            .map_err(|e| SyncError::internal().context(format!("Serialize to folder json str failed: {}", e)))?;
        let operations = FolderOperationsBuilder::new().insert(&json).build();

        Ok(Self { folder_rev, operations })
    }

    pub fn from_revisions(revisions: Vec<Revision>) -> SyncResult<Self> {
        FolderPadBuilder::new().build_with_revisions(revisions)
    }

    pub fn from_operations(operations: FolderOperations) -> SyncResult<Self> {
        let content = operations.content()?;
        let mut deserializer = serde_json::Deserializer::from_reader(content.as_bytes());

        let folder_rev = FolderRevision::deserialize(&mut deserializer).map_err(|e| {
            tracing::error!("Deserialize folder from {} failed", content);
            SyncError::internal().context(format!("Deserialize operations to folder failed: {}", e))
        })?;

        Ok(Self { folder_rev, operations })
    }

    pub fn get_operations(&self) -> &FolderOperations {
        &self.operations
    }

    pub fn reset_folder(&mut self, operations: FolderOperations) -> SyncResult<String> {
        let folder = FolderPad::from_operations(operations)?;
        self.folder_rev = folder.folder_rev;
        self.operations = folder.operations;

        Ok(self.folder_md5())
    }

    pub fn compose_remote_operations(&mut self, operations: FolderOperations) -> SyncResult<String> {
        let composed_operations = self.operations.compose(&operations)?;
        self.reset_folder(composed_operations)
    }

    pub fn is_empty(&self) -> bool {
        self.folder_rev.workspaces.is_empty() && self.folder_rev.trash.is_empty()
    }

    #[tracing::instrument(level = "trace", skip(self, workspace_rev), fields(workspace_name=%workspace_rev.name), err)]
    pub fn create_workspace(&mut self, workspace_rev: WorkspaceRevision) -> SyncResult<Option<FolderChangeset>> {
        let workspace = Arc::new(workspace_rev);
        if self.folder_rev.workspaces.contains(&workspace) {
            tracing::warn!("[RootFolder]: Duplicate workspace");
            return Ok(None);
        }

        self.modify_workspaces(move |workspaces| {
            workspaces.push(workspace);
            Ok(Some(()))
        })
    }

    pub fn update_workspace(
        &mut self,
        workspace_id: &str,
        name: Option<String>,
        desc: Option<String>,
    ) -> SyncResult<Option<FolderChangeset>> {
        self.with_workspace(workspace_id, |workspace| {
            if let Some(name) = name {
                workspace.name = name;
            }

            if let Some(desc) = desc {
                workspace.desc = desc;
            }
            Ok(Some(()))
        })
    }

    pub fn read_workspaces(&self, workspace_id: Option<String>) -> SyncResult<Vec<WorkspaceRevision>> {
        match workspace_id {
            None => {
                let workspaces = self
                    .folder_rev
                    .workspaces
                    .iter()
                    .map(|workspace| workspace.as_ref().clone())
                    .collect::<Vec<WorkspaceRevision>>();
                Ok(workspaces)
            }
            Some(workspace_id) => {
                if let Some(workspace) = self
                    .folder_rev
                    .workspaces
                    .iter()
                    .find(|workspace| workspace.id == workspace_id)
                {
                    Ok(vec![workspace.as_ref().clone()])
                } else {
                    Err(SyncError::record_not_found().context(format!("Can't find workspace with id {}", workspace_id)))
                }
            }
        }
    }

    #[tracing::instrument(level = "trace", skip(self), err)]
    pub fn delete_workspace(&mut self, workspace_id: &str) -> SyncResult<Option<FolderChangeset>> {
        self.modify_workspaces(|workspaces| {
            workspaces.retain(|w| w.id != workspace_id);
            Ok(Some(()))
        })
    }

    #[tracing::instrument(level = "trace", skip(self), fields(app_name=%app_rev.name), err)]
    pub fn create_app(&mut self, app_rev: AppRevision) -> SyncResult<Option<FolderChangeset>> {
        let workspace_id = app_rev.workspace_id.clone();
        self.with_workspace(&workspace_id, move |workspace| {
            if workspace.apps.contains(&app_rev) {
                tracing::warn!("[RootFolder]: Duplicate app");
                return Ok(None);
            }
            workspace.apps.push(app_rev);
            Ok(Some(()))
        })
    }

    pub fn read_app(&self, app_id: &str) -> SyncResult<AppRevision> {
        for workspace in &self.folder_rev.workspaces {
            if let Some(app) = workspace.apps.iter().find(|app| app.id == app_id) {
                return Ok(app.clone());
            }
        }
        Err(SyncError::record_not_found().context(format!("Can't find app with id {}", app_id)))
    }

    pub fn update_app(
        &mut self,
        app_id: &str,
        name: Option<String>,
        desc: Option<String>,
    ) -> SyncResult<Option<FolderChangeset>> {
        self.with_app(app_id, move |app| {
            if let Some(name) = name {
                app.name = name;
            }

            if let Some(desc) = desc {
                app.desc = desc;
            }
            Ok(Some(()))
        })
    }

    #[tracing::instrument(level = "trace", skip(self), err)]
    pub fn delete_app(&mut self, app_id: &str) -> SyncResult<Option<FolderChangeset>> {
        let app = self.read_app(app_id)?;
        self.with_workspace(&app.workspace_id, |workspace| {
            workspace.apps.retain(|app| app.id != app_id);
            Ok(Some(()))
        })
    }

    #[tracing::instrument(level = "trace", skip(self), err)]
    pub fn move_app(&mut self, app_id: &str, from: usize, to: usize) -> SyncResult<Option<FolderChangeset>> {
        let app = self.read_app(app_id)?;
        self.with_workspace(&app.workspace_id, |workspace| {
            match move_vec_element(&mut workspace.apps, |app| app.id == app_id, from, to)
                .map_err(internal_sync_error)?
            {
                true => Ok(Some(())),
                false => Ok(None),
            }
        })
    }

    #[tracing::instrument(level = "trace", skip(self), fields(view_name=%view_rev.name), err)]
    pub fn create_view(&mut self, view_rev: ViewRevision) -> SyncResult<Option<FolderChangeset>> {
        let app_id = view_rev.app_id.clone();
        self.with_app(&app_id, move |app| {
            if app.belongings.contains(&view_rev) {
                tracing::warn!("[RootFolder]: Duplicate view");
                return Ok(None);
            }
            app.belongings.push(view_rev);
            Ok(Some(()))
        })
    }

    pub fn read_view(&self, view_id: &str) -> SyncResult<ViewRevision> {
        for workspace in &self.folder_rev.workspaces {
            for app in &(*workspace.apps) {
                if let Some(view) = app.belongings.iter().find(|b| b.id == view_id) {
                    return Ok(view.clone());
                }
            }
        }
        Err(SyncError::record_not_found().context(format!("Can't find view with id {}", view_id)))
    }

    pub fn read_views(&self, belong_to_id: &str) -> SyncResult<Vec<ViewRevision>> {
        for workspace in &self.folder_rev.workspaces {
            for app in &(*workspace.apps) {
                if app.id == belong_to_id {
                    return Ok(app.belongings.to_vec());
                }
            }
        }
        Ok(vec![])
    }

    pub fn update_view(
        &mut self,
        view_id: &str,
        name: Option<String>,
        desc: Option<String>,
        modified_time: i64,
    ) -> SyncResult<Option<FolderChangeset>> {
        let view = self.read_view(view_id)?;
        self.with_view(&view.app_id, view_id, |view| {
            if let Some(name) = name {
                view.name = name;
            }

            if let Some(desc) = desc {
                view.desc = desc;
            }

            view.modified_time = modified_time;
            Ok(Some(()))
        })
    }

    #[tracing::instrument(level = "trace", skip(self), err)]
    pub fn delete_view(&mut self, app_id: &str, view_id: &str) -> SyncResult<Option<FolderChangeset>> {
        self.with_app(app_id, |app| {
            app.belongings.retain(|view| view.id != view_id);
            Ok(Some(()))
        })
    }

    #[tracing::instrument(level = "trace", skip(self), err)]
    pub fn move_view(&mut self, view_id: &str, from: usize, to: usize) -> SyncResult<Option<FolderChangeset>> {
        let view = self.read_view(view_id)?;
        self.with_app(&view.app_id, |app| {
            match move_vec_element(&mut app.belongings, |view| view.id == view_id, from, to)
                .map_err(internal_sync_error)?
            {
                true => Ok(Some(())),
                false => Ok(None),
            }
        })
    }

    pub fn create_trash(&mut self, trash: Vec<TrashRevision>) -> SyncResult<Option<FolderChangeset>> {
        self.with_trash(|original_trash| {
            let mut new_trash = trash
                .into_iter()
                .flat_map(|new_trash| {
                    if original_trash.iter().any(|old_trash| old_trash.id == new_trash.id) {
                        None
                    } else {
                        Some(Arc::new(new_trash))
                    }
                })
                .collect::<Vec<Arc<TrashRevision>>>();
            if new_trash.is_empty() {
                Ok(None)
            } else {
                original_trash.append(&mut new_trash);
                Ok(Some(()))
            }
        })
    }

    pub fn read_trash(&self, trash_id: Option<String>) -> SyncResult<Vec<TrashRevision>> {
        match trash_id {
            None => {
                // Removes the duplicate items if exist
                let mut trash_items = Vec::<TrashRevision>::with_capacity(self.folder_rev.trash.len());
                for trash_item in self.folder_rev.trash.iter() {
                    if !trash_items.iter().any(|item| item.id == trash_item.id) {
                        trash_items.push(trash_item.as_ref().clone());
                    }
                }
                Ok(trash_items)
            }
            Some(trash_id) => match self.folder_rev.trash.iter().find(|t| t.id == trash_id) {
                Some(trash) => Ok(vec![trash.as_ref().clone()]),
                None => Ok(vec![]),
            },
        }
    }

    pub fn delete_trash(&mut self, trash_ids: Option<Vec<String>>) -> SyncResult<Option<FolderChangeset>> {
        match trash_ids {
            None => self.with_trash(|trash| {
                trash.clear();
                Ok(Some(()))
            }),
            Some(trash_ids) => self.with_trash(|trash| {
                trash.retain(|t| !trash_ids.contains(&t.id));
                Ok(Some(()))
            }),
        }
    }

    pub fn folder_md5(&self) -> String {
        md5(&self.operations.json_bytes())
    }

    pub fn to_json(&self) -> SyncResult<String> {
        make_folder_rev_json_str(&self.folder_rev)
    }
}

pub fn make_folder_rev_json_str(folder_rev: &FolderRevision) -> SyncResult<String> {
    let json = serde_json::to_string(folder_rev)
        .map_err(|err| internal_sync_error(format!("Serialize folder to json str failed. {:?}", err)))?;
    Ok(json)
}

impl FolderPad {
    fn modify_workspaces<F>(&mut self, f: F) -> SyncResult<Option<FolderChangeset>>
    where
        F: FnOnce(&mut Vec<Arc<WorkspaceRevision>>) -> SyncResult<Option<()>>,
    {
        let cloned_self = self.clone();
        match f(&mut self.folder_rev.workspaces)? {
            None => Ok(None),
            Some(_) => {
                let old = cloned_self.to_json()?;
                let new = self.to_json()?;
                match cal_diff::<EmptyAttributes>(old, new) {
                    None => Ok(None),
                    Some(operations) => {
                        self.operations = self.operations.compose(&operations)?;
                        Ok(Some(FolderChangeset {
                            operations,
                            md5: self.folder_md5(),
                        }))
                    }
                }
            }
        }
    }

    fn with_workspace<F>(&mut self, workspace_id: &str, f: F) -> SyncResult<Option<FolderChangeset>>
    where
        F: FnOnce(&mut WorkspaceRevision) -> SyncResult<Option<()>>,
    {
        self.modify_workspaces(|workspaces| {
            if let Some(workspace) = workspaces.iter_mut().find(|workspace| workspace_id == workspace.id) {
                f(Arc::make_mut(workspace))
            } else {
                tracing::warn!("[FolderPad]: Can't find any workspace with id: {}", workspace_id);
                Ok(None)
            }
        })
    }

    fn with_trash<F>(&mut self, f: F) -> SyncResult<Option<FolderChangeset>>
    where
        F: FnOnce(&mut Vec<Arc<TrashRevision>>) -> SyncResult<Option<()>>,
    {
        let cloned_self = self.clone();
        match f(&mut self.folder_rev.trash)? {
            None => Ok(None),
            Some(_) => {
                let old = cloned_self.to_json()?;
                let new = self.to_json()?;
                match cal_diff::<EmptyAttributes>(old, new) {
                    None => Ok(None),
                    Some(operations) => {
                        self.operations = self.operations.compose(&operations)?;
                        Ok(Some(FolderChangeset {
                            operations,
                            md5: self.folder_md5(),
                        }))
                    }
                }
            }
        }
    }

    fn with_app<F>(&mut self, app_id: &str, f: F) -> SyncResult<Option<FolderChangeset>>
    where
        F: FnOnce(&mut AppRevision) -> SyncResult<Option<()>>,
    {
        let workspace_id = match self
            .folder_rev
            .workspaces
            .iter()
            .find(|workspace| workspace.apps.iter().any(|app| app.id == app_id))
        {
            None => {
                tracing::warn!("[FolderPad]: Can't find any app with id: {}", app_id);
                return Ok(None);
            }
            Some(workspace) => workspace.id.clone(),
        };

        self.with_workspace(&workspace_id, |workspace| {
            // It's ok to unwrap because we get the workspace from the app_id.
            f(workspace.apps.iter_mut().find(|app| app_id == app.id).unwrap())
        })
    }

    fn with_view<F>(&mut self, belong_to_id: &str, view_id: &str, f: F) -> SyncResult<Option<FolderChangeset>>
    where
        F: FnOnce(&mut ViewRevision) -> SyncResult<Option<()>>,
    {
        self.with_app(belong_to_id, |app| {
            match app.belongings.iter_mut().find(|view| view_id == view.id) {
                None => {
                    tracing::warn!("[FolderPad]: Can't find any view with id: {}", view_id);
                    Ok(None)
                }
                Some(view) => f(view),
            }
        })
    }
}

pub fn default_folder_operations() -> FolderOperations {
    FolderOperationsBuilder::new()
        .insert(r#"{"workspaces":[],"trash":[]}"#)
        .build()
}

pub fn initial_folder_operations(folder_pad: &FolderPad) -> SyncResult<FolderOperations> {
    let json = folder_pad.to_json()?;
    let operations = FolderOperationsBuilder::new().insert(&json).build();
    Ok(operations)
}

pub struct FolderChangeset {
    pub operations: FolderOperations,
    /// md5: the md5 of the FolderPad's operations after applying the change.
    pub md5: String,
}

#[cfg(test)]
mod tests {
    #![allow(clippy::all)]
    use crate::client_folder::folder_pad::FolderPad;
    use crate::client_folder::{FolderOperations, FolderOperationsBuilder};
    use chrono::Utc;
    use folder_model::{AppRevision, FolderRevision, TrashRevision, ViewRevision, WorkspaceRevision};
    use lib_ot::core::OperationTransform;
    use serde::Deserialize;

    #[test]
    fn folder_add_workspace() {
        let (mut folder, initial_operations, _) = test_folder();

        let _time = Utc::now();
        let mut workspace_1 = WorkspaceRevision::default();
        workspace_1.name = "My first workspace".to_owned();
        let operations_1 = folder.create_workspace(workspace_1).unwrap().unwrap().operations;

        let mut workspace_2 = WorkspaceRevision::default();
        workspace_2.name = "My second workspace".to_owned();
        let operations_2 = folder.create_workspace(workspace_2).unwrap().unwrap().operations;

        let folder_from_operations = make_folder_from_operations(initial_operations, vec![operations_1, operations_2]);
        assert_eq!(folder, folder_from_operations);
    }

    #[test]
    fn folder_deserialize_invalid_json_test() {
        for json in vec![
            // No timestamp
            r#"{"workspaces":[{"id":"1","name":"first workspace","desc":"","apps":[]}],"trash":[]}"#,
            // Trailing characters
            r#"{"workspaces":[{"id":"1","name":"first workspace","desc":"","apps":[]}],"trash":[]}123"#,
        ] {
            let mut deserializer = serde_json::Deserializer::from_reader(json.as_bytes());
            let folder_rev = FolderRevision::deserialize(&mut deserializer).unwrap();
            assert_eq!(folder_rev.workspaces.first().as_ref().unwrap().name, "first workspace");
        }
    }

    #[test]
    fn folder_update_workspace() {
        let (mut folder, initial_operation, workspace) = test_folder();
        assert_folder_equal(
            &folder,
            &make_folder_from_operations(initial_operation.clone(), vec![]),
            r#"{"workspaces":[{"id":"1","name":"😁 my first workspace","desc":"","apps":[],"modified_time":0,"create_time":0}],"trash":[]}"#,
        );

        let operations = folder
            .update_workspace(&workspace.id, Some("☺️ rename workspace️".to_string()), None)
            .unwrap()
            .unwrap()
            .operations;

        let folder_from_operations = make_folder_from_operations(initial_operation, vec![operations]);
        assert_folder_equal(
            &folder,
            &folder_from_operations,
            r#"{"workspaces":[{"id":"1","name":"☺️ rename workspace️","desc":"","apps":[],"modified_time":0,"create_time":0}],"trash":[]}"#,
        );
    }

    #[test]
    fn folder_add_app() {
        let (folder, initial_operations, _app) = test_app_folder();
        let folder_from_operations = make_folder_from_operations(initial_operations, vec![]);
        assert_eq!(folder, folder_from_operations);
        assert_folder_equal(
            &folder,
            &folder_from_operations,
            r#"{
                "workspaces": [
                    {
                        "id": "1",
                        "name": "😁 my first workspace",
                        "desc": "",
                        "apps": [
                            {
                                "id": "",
                                "workspace_id": "1",
                                "name": "😁 my first app",
                                "desc": "",
                                "belongings": [],
                                "version": 0,
                                "modified_time": 0,
                                "create_time": 0
                            }
                        ],
                        "modified_time": 0,
                        "create_time": 0
                    }
                ],
                "trash": []
            }"#,
        );
    }

    #[test]
    fn folder_update_app() {
        let (mut folder, initial_operations, app) = test_app_folder();
        let operations = folder
            .update_app(&app.id, Some("🤪 rename app".to_owned()), None)
            .unwrap()
            .unwrap()
            .operations;

        let new_folder = make_folder_from_operations(initial_operations, vec![operations]);
        assert_folder_equal(
            &folder,
            &new_folder,
            r#"{
                "workspaces": [
                    {
                        "id": "1",
                        "name": "😁 my first workspace",
                        "desc": "",
                        "apps": [
                            {
                                "id": "",
                                "workspace_id": "1",
                                "name": "🤪 rename app",
                                "desc": "",
                                "belongings": [],
                                "version": 0,
                                "modified_time": 0,
                                "create_time": 0
                            }
                        ],
                        "modified_time": 0,
                        "create_time": 0
                    }
                ],
                "trash": []
            }"#,
        );
    }

    #[test]
    fn folder_delete_app() {
        let (mut folder, initial_operations, app) = test_app_folder();
        let operations = folder.delete_app(&app.id).unwrap().unwrap().operations;
        let new_folder = make_folder_from_operations(initial_operations, vec![operations]);
        assert_folder_equal(
            &folder,
            &new_folder,
            r#"{
                "workspaces": [
                    {
                        "id": "1",
                        "name": "😁 my first workspace",
                        "desc": "",
                        "apps": [],
                        "modified_time": 0,
                        "create_time": 0
                    }
                ],
                "trash": []
            }"#,
        );
    }

    #[test]
    fn folder_add_view() {
        let (folder, initial_operations, _view) = test_view_folder();
        assert_folder_equal(
            &folder,
            &make_folder_from_operations(initial_operations, vec![]),
            r#"
        {
            "workspaces": [
                {
                    "id": "1",
                    "name": "😁 my first workspace",
                    "desc": "",
                    "apps": [
                        {
                            "id": "",
                            "workspace_id": "1",
                            "name": "😁 my first app",
                            "desc": "",
                            "belongings": [
                                {
                                    "id": "",
                                    "belong_to_id": "",
                                    "name": "🎃 my first view",
                                    "desc": "",
                                    "view_type": "Blank",
                                    "version": 0,
                                    "belongings": [],
                                    "modified_time": 0,
                                    "create_time": 0
                                }
                            ],
                            "version": 0,
                            "modified_time": 0,
                            "create_time": 0
                        }
                    ],
                    "modified_time": 0,
                    "create_time": 0
                }
            ],
            "trash": []
        }"#,
        );
    }

    #[test]
    fn folder_update_view() {
        let (mut folder, initial_operations, view) = test_view_folder();
        let operations = folder
            .update_view(&view.id, Some("😦 rename view".to_owned()), None, 123)
            .unwrap()
            .unwrap()
            .operations;

        let new_folder = make_folder_from_operations(initial_operations, vec![operations]);
        assert_folder_equal(
            &folder,
            &new_folder,
            r#"{
                "workspaces": [
                    {
                        "id": "1",
                        "name": "😁 my first workspace",
                        "desc": "",
                        "apps": [
                            {
                                "id": "",
                                "workspace_id": "1",
                                "name": "😁 my first app",
                                "desc": "",
                                "belongings": [
                                    {
                                        "id": "",
                                        "belong_to_id": "",
                                        "name": "😦 rename view",
                                        "desc": "",
                                        "view_type": "Blank",
                                        "version": 0,
                                        "belongings": [],
                                        "modified_time": 123,
                                        "create_time": 0
                                    }
                                ],
                                "version": 0,
                                "modified_time": 0,
                                "create_time": 0
                            }
                        ],
                        "modified_time": 0,
                        "create_time": 0
                    }
                ],
                "trash": []
            }"#,
        );
    }

    #[test]
    fn folder_delete_view() {
        let (mut folder, initial_operations, view) = test_view_folder();
        let operations = folder.delete_view(&view.app_id, &view.id).unwrap().unwrap().operations;

        let new_folder = make_folder_from_operations(initial_operations, vec![operations]);
        assert_folder_equal(
            &folder,
            &new_folder,
            r#"{
                "workspaces": [
                    {
                        "id": "1",
                        "name": "😁 my first workspace",
                        "desc": "",
                        "apps": [
                            {
                                "id": "",
                                "workspace_id": "1",
                                "name": "😁 my first app",
                                "desc": "",
                                "belongings": [],
                                "version": 0,
                                "modified_time": 0,
                                "create_time": 0
                            }
                        ],
                        "modified_time": 0,
                        "create_time": 0
                    }
                ],
                "trash": []
            }"#,
        );
    }

    #[test]
    fn folder_add_trash() {
        let (folder, initial_operations, _trash) = test_trash();
        assert_folder_equal(
            &folder,
            &make_folder_from_operations(initial_operations, vec![]),
            r#"{
                    "workspaces": [],
                    "trash": [
                        {
                            "id": "1",
                            "name": "🚽 my first trash",
                            "modified_time": 0,
                            "create_time": 0,
                            "ty": 0 
                        }
                    ]
                }
            "#,
        );
    }

    #[test]
    fn folder_delete_trash() {
        let (mut folder, initial_operations, trash) = test_trash();
        let operations = folder.delete_trash(Some(vec![trash.id])).unwrap().unwrap().operations;
        assert_folder_equal(
            &folder,
            &make_folder_from_operations(initial_operations, vec![operations]),
            r#"{
                    "workspaces": [],
                    "trash": []
                }
            "#,
        );
    }

    fn test_folder() -> (FolderPad, FolderOperations, WorkspaceRevision) {
        let folder_rev = FolderRevision::default();
        let folder_json = serde_json::to_string(&folder_rev).unwrap();
        let mut operations = FolderOperationsBuilder::new().insert(&folder_json).build();

        let mut workspace_rev = WorkspaceRevision::default();
        workspace_rev.name = "😁 my first workspace".to_owned();
        workspace_rev.id = "1".to_owned();

        let mut folder = FolderPad::from_folder_rev(folder_rev).unwrap();

        operations = operations
            .compose(
                &folder
                    .create_workspace(workspace_rev.clone())
                    .unwrap()
                    .unwrap()
                    .operations,
            )
            .unwrap();

        (folder, operations, workspace_rev)
    }

    fn test_app_folder() -> (FolderPad, FolderOperations, AppRevision) {
        let (mut folder_rev, mut initial_operations, workspace) = test_folder();
        let mut app_rev = AppRevision::default();
        app_rev.workspace_id = workspace.id;
        app_rev.name = "😁 my first app".to_owned();

        initial_operations = initial_operations
            .compose(&folder_rev.create_app(app_rev.clone()).unwrap().unwrap().operations)
            .unwrap();

        (folder_rev, initial_operations, app_rev)
    }

    fn test_view_folder() -> (FolderPad, FolderOperations, ViewRevision) {
        let (mut folder, mut initial_operations, app) = test_app_folder();
        let mut view_rev = ViewRevision::default();
        view_rev.app_id = app.id.clone();
        view_rev.name = "🎃 my first view".to_owned();

        initial_operations = initial_operations
            .compose(&folder.create_view(view_rev.clone()).unwrap().unwrap().operations)
            .unwrap();

        (folder, initial_operations, view_rev)
    }

    fn test_trash() -> (FolderPad, FolderOperations, TrashRevision) {
        let folder_rev = FolderRevision::default();
        let folder_json = serde_json::to_string(&folder_rev).unwrap();
        let mut operations = FolderOperationsBuilder::new().insert(&folder_json).build();

        let mut trash_rev = TrashRevision::default();
        trash_rev.name = "🚽 my first trash".to_owned();
        trash_rev.id = "1".to_owned();
        let mut folder = FolderPad::from_folder_rev(folder_rev).unwrap();
        operations = operations
            .compose(
                &folder
                    .create_trash(vec![trash_rev.clone().into()])
                    .unwrap()
                    .unwrap()
                    .operations,
            )
            .unwrap();

        (folder, operations, trash_rev)
    }

    fn make_folder_from_operations(
        mut initial_operation: FolderOperations,
        operations: Vec<FolderOperations>,
    ) -> FolderPad {
        for operation in operations {
            initial_operation = initial_operation.compose(&operation).unwrap();
        }
        FolderPad::from_operations(initial_operation).unwrap()
    }

    fn assert_folder_equal(old: &FolderPad, new: &FolderPad, expected: &str) {
        assert_eq!(old, new);

        let json1 = old.to_json().unwrap();
        let json2 = new.to_json().unwrap();

        // format the json str
        let folder_rev: FolderRevision = serde_json::from_str(expected).unwrap();
        let expected = serde_json::to_string(&folder_rev).unwrap();

        assert_eq!(json1, expected);
        assert_eq!(json1, json2);
    }
}