rename flowy-core to flowy-folder that manages the workspace,app,view

frontend/rust-lib/flowy-folder/tests/workspace/folder_test.rs

@@ -0,0 +1,365 @@
+use crate::script::{invalid_workspace_name_test_case, FolderScript::*, FolderTest};
+use flowy_collaboration::{client_document::default::initial_delta_string, entities::revision::RevisionState};
+use flowy_folder::entities::workspace::CreateWorkspaceRequest;
+use flowy_test::{event_builder::*, FlowySDKTest};
+
+#[tokio::test]
+async fn workspace_read_all() {
+    let mut test = FolderTest::new().await;
+    test.run_scripts(vec![ReadAllWorkspaces]).await;
+    // The first workspace will be the default workspace
+    // The second workspace will be created by FolderTest
+    assert_eq!(test.all_workspace.len(), 2);
+
+    let new_name = "My new workspace".to_owned();
+    test.run_scripts(vec![
+        CreateWorkspace {
+            name: new_name.clone(),
+            desc: "Daily routines".to_owned(),
+        },
+        ReadAllWorkspaces,
+    ])
+    .await;
+    assert_eq!(test.all_workspace.len(), 3);
+    assert_eq!(test.all_workspace[2].name, new_name);
+}
+
+#[tokio::test]
+async fn workspace_create() {
+    let mut test = FolderTest::new().await;
+    let name = "My new workspace".to_owned();
+    let desc = "Daily routines".to_owned();
+    test.run_scripts(vec![CreateWorkspace {
+        name: name.clone(),
+        desc: desc.clone(),
+    }])
+    .await;
+
+    let workspace = test.workspace.clone();
+    assert_eq!(workspace.name, name);
+    assert_eq!(workspace.desc, desc);
+
+    test.run_scripts(vec![
+        ReadWorkspace(Some(workspace.id.clone())),
+        AssertWorkspace(workspace),
+    ])
+    .await;
+}
+
+#[tokio::test]
+async fn workspace_read() {
+    let mut test = FolderTest::new().await;
+    let workspace = test.workspace.clone();
+    let json = serde_json::to_string(&workspace).unwrap();
+
+    test.run_scripts(vec![
+        ReadWorkspace(Some(workspace.id.clone())),
+        AssertWorkspaceJson(json),
+        AssertWorkspace(workspace),
+    ])
+    .await;
+}
+
+#[tokio::test]
+async fn workspace_create_with_apps() {
+    let mut test = FolderTest::new().await;
+    test.run_scripts(vec![CreateApp {
+        name: "App".to_string(),
+        desc: "App description".to_string(),
+    }])
+    .await;
+
+    let app = test.app.clone();
+    let json = serde_json::to_string(&app).unwrap();
+    test.run_scripts(vec![ReadApp(app.id), AssertAppJson(json)]).await;
+}
+
+#[tokio::test]
+async fn workspace_create_with_invalid_name() {
+    for (name, code) in invalid_workspace_name_test_case() {
+        let sdk = FlowySDKTest::default();
+        let request = CreateWorkspaceRequest {
+            name,
+            desc: "".to_owned(),
+        };
+        assert_eq!(
+            FolderEventBuilder::new(sdk)
+                .event(flowy_folder::event::FolderEvent::CreateWorkspace)
+                .request(request)
+                .async_send()
+                .await
+                .error()
+                .code,
+            code.value()
+        )
+    }
+}
+
+#[tokio::test]
+#[should_panic]
+async fn app_delete() {
+    let mut test = FolderTest::new().await;
+    let app = test.app.clone();
+    test.run_scripts(vec![DeleteApp, ReadApp(app.id)]).await;
+}
+
+#[tokio::test]
+async fn app_delete_then_restore() {
+    let mut test = FolderTest::new().await;
+    let app = test.app.clone();
+    test.run_scripts(vec![
+        DeleteApp,
+        RestoreAppFromTrash,
+        ReadApp(app.id.clone()),
+        AssertApp(app),
+    ])
+    .await;
+}
+
+#[tokio::test]
+async fn app_read() {
+    let mut test = FolderTest::new().await;
+    let app = test.app.clone();
+    test.run_scripts(vec![ReadApp(app.id.clone()), AssertApp(app)]).await;
+}
+
+#[tokio::test]
+async fn app_update() {
+    let mut test = FolderTest::new().await;
+    let app = test.app.clone();
+    let new_name = "😁 hell world".to_owned();
+    assert_ne!(app.name, new_name);
+
+    test.run_scripts(vec![
+        UpdateApp {
+            name: Some(new_name.clone()),
+            desc: None,
+        },
+        ReadApp(app.id),
+    ])
+    .await;
+    assert_eq!(test.app.name, new_name);
+}
+
+#[tokio::test]
+async fn app_create_with_view() {
+    let mut test = FolderTest::new().await;
+    let mut app = test.app.clone();
+    test.run_scripts(vec![
+        CreateView {
+            name: "View A".to_owned(),
+            desc: "View A description".to_owned(),
+        },
+        CreateView {
+            name: "View B".to_owned(),
+            desc: "View B description".to_owned(),
+        },
+        ReadApp(app.id),
+    ])
+    .await;
+
+    app = test.app.clone();
+    assert_eq!(app.belongings.len(), 3);
+    assert_eq!(app.belongings[1].name, "View A");
+    assert_eq!(app.belongings[2].name, "View B")
+}
+
+#[tokio::test]
+async fn view_update() {
+    let mut test = FolderTest::new().await;
+    let view = test.view.clone();
+    let new_name = "😁 123".to_owned();
+    assert_ne!(view.name, new_name);
+
+    test.run_scripts(vec![
+        UpdateView {
+            name: Some(new_name.clone()),
+            desc: None,
+        },
+        ReadView(view.id),
+    ])
+    .await;
+    assert_eq!(test.view.name, new_name);
+}
+
+#[tokio::test]
+async fn open_document_view() {
+    let mut test = FolderTest::new().await;
+    assert_eq!(test.document_info, None);
+
+    test.run_scripts(vec![OpenDocument]).await;
+    let document_info = test.document_info.unwrap();
+    assert_eq!(document_info.text, initial_delta_string());
+}
+
+#[tokio::test]
+#[should_panic]
+async fn view_delete() {
+    let mut test = FolderTest::new().await;
+    let view = test.view.clone();
+    test.run_scripts(vec![DeleteView, ReadView(view.id)]).await;
+}
+
+#[tokio::test]
+async fn view_delete_then_restore() {
+    let mut test = FolderTest::new().await;
+    let view = test.view.clone();
+    test.run_scripts(vec![
+        DeleteView,
+        RestoreViewFromTrash,
+        ReadView(view.id.clone()),
+        AssertView(view),
+    ])
+    .await;
+}
+
+#[tokio::test]
+async fn view_delete_all() {
+    let mut test = FolderTest::new().await;
+    let app = test.app.clone();
+    test.run_scripts(vec![
+        CreateView {
+            name: "View A".to_owned(),
+            desc: "View A description".to_owned(),
+        },
+        CreateView {
+            name: "View B".to_owned(),
+            desc: "View B description".to_owned(),
+        },
+        ReadApp(app.id.clone()),
+    ])
+    .await;
+
+    assert_eq!(test.app.belongings.len(), 3);
+    let view_ids = test
+        .app
+        .belongings
+        .iter()
+        .map(|view| view.id.clone())
+        .collect::<Vec<String>>();
+    test.run_scripts(vec![DeleteViews(view_ids), ReadApp(app.id), ReadTrash])
+        .await;
+
+    assert_eq!(test.app.belongings.len(), 0);
+    assert_eq!(test.trash.len(), 3);
+}
+
+#[tokio::test]
+async fn view_delete_all_permanent() {
+    let mut test = FolderTest::new().await;
+    let app = test.app.clone();
+    test.run_scripts(vec![
+        CreateView {
+            name: "View A".to_owned(),
+            desc: "View A description".to_owned(),
+        },
+        ReadApp(app.id.clone()),
+    ])
+    .await;
+
+    let view_ids = test
+        .app
+        .belongings
+        .iter()
+        .map(|view| view.id.clone())
+        .collect::<Vec<String>>();
+    test.run_scripts(vec![DeleteViews(view_ids), ReadApp(app.id), DeleteAllTrash, ReadTrash])
+        .await;
+
+    assert_eq!(test.app.belongings.len(), 0);
+    assert_eq!(test.trash.len(), 0);
+}
+
+#[tokio::test]
+async fn folder_sync_revision_state() {
+    let mut test = FolderTest::new().await;
+    test.run_scripts(vec![
+        AssertRevisionState {
+            rev_id: 1,
+            state: RevisionState::Sync,
+        },
+        AssertNextSyncRevId(Some(1)),
+        AssertRevisionState {
+            rev_id: 1,
+            state: RevisionState::Ack,
+        },
+    ])
+    .await;
+}
+
+#[tokio::test]
+async fn folder_sync_revision_seq() {
+    let mut test = FolderTest::new().await;
+    test.run_scripts(vec![
+        AssertRevisionState {
+            rev_id: 1,
+            state: RevisionState::Sync,
+        },
+        AssertRevisionState {
+            rev_id: 2,
+            state: RevisionState::Sync,
+        },
+        AssertNextSyncRevId(Some(1)),
+        AssertNextSyncRevId(Some(2)),
+        AssertRevisionState {
+            rev_id: 1,
+            state: RevisionState::Ack,
+        },
+        AssertRevisionState {
+            rev_id: 2,
+            state: RevisionState::Ack,
+        },
+    ])
+    .await;
+}
+
+#[tokio::test]
+async fn folder_sync_revision_with_new_app() {
+    let mut test = FolderTest::new().await;
+    let app_name = "AppFlowy contributors".to_owned();
+    let app_desc = "Welcome to be a AppFlowy contributor".to_owned();
+
+    test.run_scripts(vec![
+        AssertNextSyncRevId(Some(1)),
+        AssertNextSyncRevId(Some(2)),
+        CreateApp {
+            name: app_name.clone(),
+            desc: app_desc.clone(),
+        },
+        AssertCurrentRevId(3),
+        AssertNextSyncRevId(Some(3)),
+        AssertNextSyncRevId(None),
+    ])
+    .await;
+
+    let app = test.app.clone();
+    assert_eq!(app.name, app_name);
+    assert_eq!(app.desc, app_desc);
+    test.run_scripts(vec![ReadApp(app.id.clone()), AssertApp(app)]).await;
+}
+
+#[tokio::test]
+async fn folder_sync_revision_with_new_view() {
+    let mut test = FolderTest::new().await;
+    let view_name = "AppFlowy features".to_owned();
+    let view_desc = "😁".to_owned();
+
+    test.run_scripts(vec![
+        AssertNextSyncRevId(Some(1)),
+        AssertNextSyncRevId(Some(2)),
+        CreateView {
+            name: view_name.clone(),
+            desc: view_desc.clone(),
+        },
+        AssertCurrentRevId(3),
+        AssertNextSyncRevId(Some(3)),
+        AssertNextSyncRevId(None),
+    ])
+    .await;
+
+    let view = test.view.clone();
+    assert_eq!(view.name, view_name);
+    assert_eq!(view.desc, view_desc);
+    test.run_scripts(vec![ReadView(view.id.clone()), AssertView(view)])
+        .await;
+}

frontend/rust-lib/flowy-folder/tests/workspace/helper.rs

@@ -0,0 +1,209 @@
+use flowy_collaboration::entities::document_info::DocumentInfo;
+use flowy_folder::event::FolderEvent::*;
+use flowy_folder_data_model::entities::{
+    app::{App, AppId, CreateAppRequest, QueryAppRequest, UpdateAppRequest},
+    trash::{RepeatedTrash, TrashId, TrashType},
+    view::{CreateViewRequest, QueryViewRequest, UpdateViewRequest, View, ViewType},
+    workspace::{CreateWorkspaceRequest, QueryWorkspaceRequest, RepeatedWorkspace, Workspace},
+};
+use flowy_test::{event_builder::*, FlowySDKTest};
+
+pub async fn create_workspace(sdk: &FlowySDKTest, name: &str, desc: &str) -> Workspace {
+    let request = CreateWorkspaceRequest {
+        name: name.to_owned(),
+        desc: desc.to_owned(),
+    };
+
+    let workspace = FolderEventBuilder::new(sdk.clone())
+        .event(CreateWorkspace)
+        .request(request)
+        .async_send()
+        .await
+        .parse::<Workspace>();
+    workspace
+}
+
+pub async fn read_workspace(sdk: &FlowySDKTest, workspace_id: Option<String>) -> Vec<Workspace> {
+    let request = QueryWorkspaceRequest { workspace_id };
+    let repeated_workspace = FolderEventBuilder::new(sdk.clone())
+        .event(ReadWorkspaces)
+        .request(request.clone())
+        .async_send()
+        .await
+        .parse::<RepeatedWorkspace>();
+
+    let workspaces;
+    if let Some(workspace_id) = &request.workspace_id {
+        workspaces = repeated_workspace
+            .into_inner()
+            .into_iter()
+            .filter(|workspace| &workspace.id == workspace_id)
+            .collect::<Vec<Workspace>>();
+        debug_assert_eq!(workspaces.len(), 1);
+    } else {
+        workspaces = repeated_workspace.items;
+    }
+
+    workspaces
+}
+
+pub async fn create_app(sdk: &FlowySDKTest, workspace_id: &str, name: &str, desc: &str) -> App {
+    let create_app_request = CreateAppRequest {
+        workspace_id: workspace_id.to_owned(),
+        name: name.to_string(),
+        desc: desc.to_string(),
+        color_style: Default::default(),
+    };
+
+    let app = FolderEventBuilder::new(sdk.clone())
+        .event(CreateApp)
+        .request(create_app_request)
+        .async_send()
+        .await
+        .parse::<App>();
+    app
+}
+
+pub async fn read_app(sdk: &FlowySDKTest, app_id: &str) -> App {
+    let request = QueryAppRequest {
+        app_ids: vec![app_id.to_owned()],
+    };
+
+    let app = FolderEventBuilder::new(sdk.clone())
+        .event(ReadApp)
+        .request(request)
+        .async_send()
+        .await
+        .parse::<App>();
+
+    app
+}
+
+pub async fn update_app(sdk: &FlowySDKTest, app_id: &str, name: Option<String>, desc: Option<String>) {
+    let request = UpdateAppRequest {
+        app_id: app_id.to_string(),
+        name,
+        desc,
+        color_style: None,
+        is_trash: None,
+    };
+
+    FolderEventBuilder::new(sdk.clone())
+        .event(UpdateApp)
+        .request(request)
+        .async_send()
+        .await;
+}
+
+pub async fn delete_app(sdk: &FlowySDKTest, app_id: &str) {
+    let request = AppId {
+        app_id: app_id.to_string(),
+    };
+
+    FolderEventBuilder::new(sdk.clone())
+        .event(DeleteApp)
+        .request(request)
+        .async_send()
+        .await;
+}
+
+pub async fn create_view(sdk: &FlowySDKTest, app_id: &str, name: &str, desc: &str, view_type: ViewType) -> View {
+    let request = CreateViewRequest {
+        belong_to_id: app_id.to_string(),
+        name: name.to_string(),
+        desc: desc.to_string(),
+        thumbnail: None,
+        view_type,
+    };
+    let view = FolderEventBuilder::new(sdk.clone())
+        .event(CreateView)
+        .request(request)
+        .async_send()
+        .await
+        .parse::<View>();
+    view
+}
+
+pub async fn read_view(sdk: &FlowySDKTest, view_ids: Vec<String>) -> View {
+    let request = QueryViewRequest { view_ids };
+    FolderEventBuilder::new(sdk.clone())
+        .event(ReadView)
+        .request(request)
+        .async_send()
+        .await
+        .parse::<View>()
+}
+
+pub async fn update_view(sdk: &FlowySDKTest, view_id: &str, name: Option<String>, desc: Option<String>) {
+    let request = UpdateViewRequest {
+        view_id: view_id.to_string(),
+        name,
+        desc,
+        thumbnail: None,
+    };
+    FolderEventBuilder::new(sdk.clone())
+        .event(UpdateView)
+        .request(request)
+        .async_send()
+        .await;
+}
+
+pub async fn delete_view(sdk: &FlowySDKTest, view_ids: Vec<String>) {
+    let request = QueryViewRequest { view_ids };
+    FolderEventBuilder::new(sdk.clone())
+        .event(DeleteView)
+        .request(request)
+        .async_send()
+        .await;
+}
+
+pub async fn open_document(sdk: &FlowySDKTest, view_id: &str) -> DocumentInfo {
+    let request = QueryViewRequest {
+        view_ids: vec![view_id.to_owned()],
+    };
+    FolderEventBuilder::new(sdk.clone())
+        .event(OpenDocument)
+        .request(request)
+        .async_send()
+        .await
+        .parse::<DocumentInfo>()
+}
+
+pub async fn read_trash(sdk: &FlowySDKTest) -> RepeatedTrash {
+    FolderEventBuilder::new(sdk.clone())
+        .event(ReadTrash)
+        .async_send()
+        .await
+        .parse::<RepeatedTrash>()
+}
+
+pub async fn restore_app_from_trash(sdk: &FlowySDKTest, app_id: &str) {
+    let id = TrashId {
+        id: app_id.to_owned(),
+        ty: TrashType::App,
+    };
+    FolderEventBuilder::new(sdk.clone())
+        .event(PutbackTrash)
+        .request(id)
+        .async_send()
+        .await;
+}
+
+pub async fn restore_view_from_trash(sdk: &FlowySDKTest, view_id: &str) {
+    let id = TrashId {
+        id: view_id.to_owned(),
+        ty: TrashType::View,
+    };
+    FolderEventBuilder::new(sdk.clone())
+        .event(PutbackTrash)
+        .request(id)
+        .async_send()
+        .await;
+}
+
+pub async fn delete_all_trash(sdk: &FlowySDKTest) {
+    FolderEventBuilder::new(sdk.clone())
+        .event(DeleteAllTrash)
+        .async_send()
+        .await;
+}

frontend/rust-lib/flowy-folder/tests/workspace/main.rs

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

frontend/rust-lib/flowy-folder/tests/workspace/script.rs

@@ -0,0 +1,219 @@
+use crate::helper::*;
+use flowy_collaboration::entities::{document_info::DocumentInfo, revision::RevisionState};
+use flowy_folder::{errors::ErrorCode, services::folder_editor::FolderEditor};
+use flowy_folder_data_model::entities::{
+    app::{App, RepeatedApp},
+    trash::Trash,
+    view::{RepeatedView, View, ViewType},
+    workspace::Workspace,
+};
+use flowy_sync::REVISION_WRITE_INTERVAL_IN_MILLIS;
+use flowy_test::FlowySDKTest;
+use std::{sync::Arc, time::Duration};
+use tokio::time::sleep;
+
+pub enum FolderScript {
+    // Workspace
+    ReadAllWorkspaces,
+    CreateWorkspace { name: String, desc: String },
+    AssertWorkspaceJson(String),
+    AssertWorkspace(Workspace),
+    ReadWorkspace(Option<String>),
+
+    // App
+    CreateApp { name: String, desc: String },
+    AssertAppJson(String),
+    AssertApp(App),
+    ReadApp(String),
+    UpdateApp { name: Option<String>, desc: Option<String> },
+    DeleteApp,
+
+    // View
+    CreateView { name: String, desc: String },
+    AssertView(View),
+    ReadView(String),
+    UpdateView { name: Option<String>, desc: Option<String> },
+    DeleteView,
+    DeleteViews(Vec<String>),
+
+    // Trash
+    RestoreAppFromTrash,
+    RestoreViewFromTrash,
+    ReadTrash,
+    DeleteAllTrash,
+
+    // Document
+    OpenDocument,
+
+    // Sync
+    AssertCurrentRevId(i64),
+    AssertNextSyncRevId(Option<i64>),
+    AssertRevisionState { rev_id: i64, state: RevisionState },
+}
+
+pub struct FolderTest {
+    pub sdk: FlowySDKTest,
+    pub all_workspace: Vec<Workspace>,
+    pub workspace: Workspace,
+    pub app: App,
+    pub view: View,
+    pub trash: Vec<Trash>,
+    pub document_info: Option<DocumentInfo>,
+    // pub folder_editor:
+}
+
+impl FolderTest {
+    pub async fn new() -> Self {
+        let sdk = FlowySDKTest::default();
+        let _ = sdk.init_user().await;
+        let mut workspace = create_workspace(&sdk, "FolderWorkspace", "Folder test workspace").await;
+        let mut app = create_app(&sdk, &workspace.id, "Folder App", "Folder test app").await;
+        let view = create_view(&sdk, &app.id, "Folder View", "Folder test view", ViewType::Doc).await;
+        app.belongings = RepeatedView {
+            items: vec![view.clone()],
+        };
+
+        workspace.apps = RepeatedApp {
+            items: vec![app.clone()],
+        };
+        Self {
+            sdk,
+            all_workspace: vec![],
+            workspace,
+            app,
+            view,
+            trash: vec![],
+            document_info: None,
+        }
+    }
+
+    pub async fn run_scripts(&mut self, scripts: Vec<FolderScript>) {
+        for script in scripts {
+            self.run_script(script).await;
+        }
+    }
+
+    pub async fn run_script(&mut self, script: FolderScript) {
+        let sdk = &self.sdk;
+        let folder_editor: Arc<FolderEditor> = sdk.folder_manager.folder_editor().await;
+        let rev_manager = folder_editor.rev_manager();
+        let cache = rev_manager.revision_cache().await;
+
+        match script {
+            FolderScript::ReadAllWorkspaces => {
+                let all_workspace = read_workspace(sdk, None).await;
+                self.all_workspace = all_workspace;
+            }
+            FolderScript::CreateWorkspace { name, desc } => {
+                let workspace = create_workspace(sdk, &name, &desc).await;
+                self.workspace = workspace;
+            }
+            FolderScript::AssertWorkspaceJson(expected_json) => {
+                let workspace = read_workspace(sdk, Some(self.workspace.id.clone()))
+                    .await
+                    .pop()
+                    .unwrap();
+                let json = serde_json::to_string(&workspace).unwrap();
+                assert_eq!(json, expected_json);
+            }
+            FolderScript::AssertWorkspace(workspace) => {
+                assert_eq!(self.workspace, workspace);
+            }
+            FolderScript::ReadWorkspace(workspace_id) => {
+                let workspace = read_workspace(sdk, workspace_id).await.pop().unwrap();
+                self.workspace = workspace;
+            }
+            FolderScript::CreateApp { name, desc } => {
+                let app = create_app(sdk, &self.workspace.id, &name, &desc).await;
+                self.app = app;
+            }
+            FolderScript::AssertAppJson(expected_json) => {
+                let json = serde_json::to_string(&self.app).unwrap();
+                assert_eq!(json, expected_json);
+            }
+            FolderScript::AssertApp(app) => {
+                assert_eq!(self.app, app);
+            }
+            FolderScript::ReadApp(app_id) => {
+                let app = read_app(sdk, &app_id).await;
+                self.app = app;
+            }
+            FolderScript::UpdateApp { name, desc } => {
+                update_app(sdk, &self.app.id, name, desc).await;
+            }
+            FolderScript::DeleteApp => {
+                delete_app(sdk, &self.app.id).await;
+            }
+
+            FolderScript::CreateView { name, desc } => {
+                let view = create_view(sdk, &self.app.id, &name, &desc, ViewType::Doc).await;
+                self.view = view;
+            }
+            FolderScript::AssertView(view) => {
+                assert_eq!(self.view, view);
+            }
+            FolderScript::ReadView(view_id) => {
+                let view = read_view(sdk, vec![view_id]).await;
+                self.view = view;
+            }
+            FolderScript::UpdateView { name, desc } => {
+                update_view(sdk, &self.view.id, name, desc).await;
+            }
+            FolderScript::DeleteView => {
+                delete_view(sdk, vec![self.view.id.clone()]).await;
+            }
+            FolderScript::DeleteViews(view_ids) => {
+                delete_view(sdk, view_ids).await;
+            }
+            FolderScript::RestoreAppFromTrash => {
+                restore_app_from_trash(sdk, &self.app.id).await;
+            }
+            FolderScript::RestoreViewFromTrash => {
+                restore_view_from_trash(sdk, &self.view.id).await;
+            }
+            FolderScript::ReadTrash => {
+                let trash = read_trash(sdk).await;
+                self.trash = trash.into_inner();
+            }
+            FolderScript::DeleteAllTrash => {
+                delete_all_trash(sdk).await;
+                self.trash = vec![];
+            }
+            FolderScript::OpenDocument => {
+                let document_info = open_document(sdk, &self.view.id).await;
+                self.document_info = Some(document_info);
+            }
+            FolderScript::AssertRevisionState { rev_id, state } => {
+                let record = cache.get(rev_id).await.unwrap();
+                assert_eq!(record.state, state);
+                if let RevisionState::Ack = state {
+                    // There is a defer action that writes the revisions to disk, so we wait here.
+                    // Make sure everything is written.
+                    sleep(Duration::from_millis(2 * REVISION_WRITE_INTERVAL_IN_MILLIS)).await;
+                }
+            }
+            FolderScript::AssertCurrentRevId(rev_id) => {
+                assert_eq!(rev_manager.rev_id(), rev_id, "Current rev_id is not match");
+            }
+            FolderScript::AssertNextSyncRevId(rev_id) => {
+                let next_revision = rev_manager.next_sync_revision().await.unwrap();
+                if rev_id.is_none() {
+                    assert!(next_revision.is_none(), "Next revision should be None");
+                    return;
+                }
+                let next_revision = next_revision
+                    .unwrap_or_else(|| panic!("Expected Next revision is {}, but receive None", rev_id.unwrap()));
+                let mut receiver = rev_manager.revision_ack_receiver();
+                let _ = receiver.recv().await;
+                assert_eq!(next_revision.rev_id, rev_id.unwrap());
+            }
+        }
+    }
+}
+
+pub fn invalid_workspace_name_test_case() -> Vec<(String, ErrorCode)> {
+    vec![
+        ("".to_owned(), ErrorCode::WorkspaceNameInvalid),
+        ("1234".repeat(100), ErrorCode::WorkspaceNameTooLong),
+    ]
+}