Refactor/crate directory (#1621)

* chore: fix wanrings

* chore: remove protobuf ref in flowy-error-code

* chore: remove protobuf ref in lib-ws

* refactor: remove protobuf trait in flowy http model

* refactor: remove flowy-error-code crate

Co-authored-by: nathan <nathan@appflowy.io>

frontend/rust-lib/flowy-sync/tests/client_folder/folder_test.rs

@@ -0,0 +1,58 @@
+use flowy_sync::client_folder::{FolderNodePad, WorkspaceNode};
+
+#[test]
+fn client_folder_create_default_folder_test() {
+    let folder_pad = FolderNodePad::new();
+    let json = folder_pad.to_json(false).unwrap();
+    assert_eq!(
+        json,
+        r#"{"type":"folder","children":[{"type":"workspaces"},{"type":"trash"}]}"#
+    );
+}
+
+#[test]
+fn client_folder_create_default_folder_with_workspace_test() {
+    let mut folder_pad = FolderNodePad::new();
+    let workspace = WorkspaceNode::new(folder_pad.tree.clone(), "1".to_string(), "workspace name".to_string());
+    folder_pad.workspaces.add_workspace(workspace).unwrap();
+    let json = folder_pad.to_json(false).unwrap();
+    assert_eq!(
+        json,
+        r#"{"type":"folder","children":[{"type":"workspaces","children":[{"type":"workspace","attributes":{"id":"1","name":"workspace name"}}]},{"type":"trash"}]}"#
+    );
+
+    assert_eq!(
+        folder_pad.get_workspace("1").unwrap().get_name().unwrap(),
+        "workspace name"
+    );
+}
+
+#[test]
+fn client_folder_delete_workspace_test() {
+    let mut folder_pad = FolderNodePad::new();
+    let workspace = WorkspaceNode::new(folder_pad.tree.clone(), "1".to_string(), "workspace name".to_string());
+    folder_pad.workspaces.add_workspace(workspace).unwrap();
+    folder_pad.workspaces.remove_workspace("1");
+    let json = folder_pad.to_json(false).unwrap();
+    assert_eq!(
+        json,
+        r#"{"type":"folder","children":[{"type":"workspaces"},{"type":"trash"}]}"#
+    );
+}
+
+#[test]
+fn client_folder_update_workspace_name_test() {
+    let mut folder_pad = FolderNodePad::new();
+    let workspace = WorkspaceNode::new(folder_pad.tree.clone(), "1".to_string(), "workspace name".to_string());
+    folder_pad.workspaces.add_workspace(workspace).unwrap();
+    folder_pad
+        .workspaces
+        .get_mut_workspace("1")
+        .unwrap()
+        .set_name("my first workspace".to_string());
+
+    assert_eq!(
+        folder_pad.workspaces.get_workspace("1").unwrap().get_name().unwrap(),
+        "my first workspace"
+    );
+}

frontend/rust-lib/flowy-sync/tests/client_folder/mod.rs

@@ -0,0 +1,3 @@
+mod folder_test;
+mod script;
+mod workspace_test;

frontend/rust-lib/flowy-sync/tests/client_folder/script.rs

@@ -0,0 +1,89 @@
+use flowy_sync::client_folder::{AppNode, FolderNodePad, WorkspaceNode};
+use folder_rev_model::AppRevision;
+use lib_ot::core::Path;
+
+pub enum FolderNodePadScript {
+    CreateWorkspace { id: String, name: String },
+    DeleteWorkspace { id: String },
+    AssertPathOfWorkspace { id: String, expected_path: Path },
+    AssertNumberOfWorkspace { expected: usize },
+    CreateApp { id: String, name: String },
+    DeleteApp { id: String },
+    UpdateApp { id: String, name: String },
+    AssertApp { id: String, expected: Option<AppRevision> },
+    AssertAppContent { id: String, name: String },
+    // AssertNumberOfApps { expected: usize },
+}
+
+pub struct FolderNodePadTest {
+    folder_pad: FolderNodePad,
+}
+
+impl FolderNodePadTest {
+    pub fn new() -> FolderNodePadTest {
+        let mut folder_pad = FolderNodePad::default();
+        let workspace = WorkspaceNode::new(folder_pad.tree.clone(), "1".to_string(), "workspace name".to_string());
+        let _ = folder_pad.workspaces.add_workspace(workspace).unwrap();
+        Self { folder_pad }
+    }
+
+    pub fn run_scripts(&mut self, scripts: Vec<FolderNodePadScript>) {
+        for script in scripts {
+            self.run_script(script);
+        }
+    }
+
+    pub fn run_script(&mut self, script: FolderNodePadScript) {
+        match script {
+            FolderNodePadScript::CreateWorkspace { id, name } => {
+                let workspace = WorkspaceNode::new(self.folder_pad.tree.clone(), id, name);
+                self.folder_pad.workspaces.add_workspace(workspace).unwrap();
+            }
+            FolderNodePadScript::DeleteWorkspace { id } => {
+                self.folder_pad.workspaces.remove_workspace(id);
+            }
+            FolderNodePadScript::AssertPathOfWorkspace { id, expected_path } => {
+                let workspace_node: &WorkspaceNode = self.folder_pad.workspaces.get_workspace(id).unwrap();
+                let node_id = workspace_node.node_id.unwrap();
+                let path = self.folder_pad.tree.read().path_from_node_id(node_id);
+                assert_eq!(path, expected_path);
+            }
+            FolderNodePadScript::AssertNumberOfWorkspace { expected } => {
+                assert_eq!(self.folder_pad.workspaces.len(), expected);
+            }
+            FolderNodePadScript::CreateApp { id, name } => {
+                let app_node = AppNode::new(self.folder_pad.tree.clone(), id, name);
+                let workspace_node = self.folder_pad.get_mut_workspace("1").unwrap();
+                let _ = workspace_node.add_app(app_node).unwrap();
+            }
+            FolderNodePadScript::DeleteApp { id } => {
+                let workspace_node = self.folder_pad.get_mut_workspace("1").unwrap();
+                workspace_node.remove_app(&id);
+            }
+            FolderNodePadScript::UpdateApp { id, name } => {
+                let workspace_node = self.folder_pad.get_mut_workspace("1").unwrap();
+                workspace_node.get_mut_app(&id).unwrap().set_name(name);
+            }
+            FolderNodePadScript::AssertApp { id, expected } => {
+                let workspace_node = self.folder_pad.get_workspace("1").unwrap();
+                let app = workspace_node.get_app(&id);
+                match expected {
+                    None => assert!(app.is_none()),
+                    Some(expected_app) => {
+                        let app_node = app.unwrap();
+                        assert_eq!(expected_app.name, app_node.get_name().unwrap());
+                        assert_eq!(expected_app.id, app_node.get_id().unwrap());
+                    }
+                }
+            }
+            FolderNodePadScript::AssertAppContent { id, name } => {
+                let workspace_node = self.folder_pad.get_workspace("1").unwrap();
+                let app = workspace_node.get_app(&id).unwrap();
+                assert_eq!(app.get_name().unwrap(), name)
+            } // FolderNodePadScript::AssertNumberOfApps { expected } => {
+              //     let workspace_node = self.folder_pad.get_workspace("1").unwrap();
+              //     assert_eq!(workspace_node.apps.len(), expected);
+              // }
+        }
+    }
+}

frontend/rust-lib/flowy-sync/tests/client_folder/workspace_test.rs

@@ -0,0 +1,86 @@
+use crate::client_folder::script::FolderNodePadScript::*;
+use crate::client_folder::script::FolderNodePadTest;
+
+#[test]
+fn client_folder_create_multi_workspaces_test() {
+    let mut test = FolderNodePadTest::new();
+    test.run_scripts(vec![
+        AssertPathOfWorkspace {
+            id: "1".to_string(),
+            expected_path: vec![0, 0, 0].into(),
+        },
+        CreateWorkspace {
+            id: "a".to_string(),
+            name: "workspace a".to_string(),
+        },
+        AssertPathOfWorkspace {
+            id: "a".to_string(),
+            expected_path: vec![0, 0, 1].into(),
+        },
+        CreateWorkspace {
+            id: "b".to_string(),
+            name: "workspace b".to_string(),
+        },
+        AssertPathOfWorkspace {
+            id: "b".to_string(),
+            expected_path: vec![0, 0, 2].into(),
+        },
+        AssertNumberOfWorkspace { expected: 3 },
+        // The path of the workspace 'b' will be changed after deleting the 'a' workspace.
+        DeleteWorkspace { id: "a".to_string() },
+        AssertPathOfWorkspace {
+            id: "b".to_string(),
+            expected_path: vec![0, 0, 1].into(),
+        },
+    ]);
+}
+
+#[test]
+fn client_folder_create_app_test() {
+    let mut test = FolderNodePadTest::new();
+    test.run_scripts(vec![
+        CreateApp {
+            id: "1".to_string(),
+            name: "my first app".to_string(),
+        },
+        AssertAppContent {
+            id: "1".to_string(),
+            name: "my first app".to_string(),
+        },
+    ]);
+}
+
+#[test]
+fn client_folder_delete_app_test() {
+    let mut test = FolderNodePadTest::new();
+    test.run_scripts(vec![
+        CreateApp {
+            id: "1".to_string(),
+            name: "my first app".to_string(),
+        },
+        DeleteApp { id: "1".to_string() },
+        AssertApp {
+            id: "1".to_string(),
+            expected: None,
+        },
+    ]);
+}
+
+#[test]
+fn client_folder_update_app_test() {
+    let mut test = FolderNodePadTest::new();
+    test.run_scripts(vec![
+        CreateApp {
+            id: "1".to_string(),
+            name: "my first app".to_string(),
+        },
+        UpdateApp {
+            id: "1".to_string(),
+            name: "TODO".to_string(),
+        },
+        AssertAppContent {
+            id: "1".to_string(),
+            name: "TODO".to_string(),
+        },
+    ]);
+}

frontend/rust-lib/flowy-sync/tests/main.rs

@@ -0,0 +1 @@
+mod client_folder;