add FlowyEnv to provide default test env

rust-lib/flowy-dispatch/src/dispatch.rs

@@ -69,42 +69,6 @@ impl EventDispatch {
                 })
             }),
         }
-        // match dispatch.read() {
-        //     Ok(dispatch) => {
-        //         let dispatch = dispatch.as_ref().unwrap();
-        //         let module_map = dispatch.module_map.clone();
-        //         let service = Box::new(DispatchService { module_map });
-        //         log::trace!("Async event: {:?}", &request.event);
-        //         let service_ctx = DispatchContext {
-        //             request,
-        //             callback: Some(Box::new(callback)),
-        //         };
-        //         let join_handle = dispatch.runtime.spawn(async move {
-        //             service
-        //                 .call(service_ctx)
-        //                 .await
-        //                 .unwrap_or_else(|e|
-        // InternalError::Other(format!("{:?}", e)).as_response())
-        //         });
-        //
-        //         DispatchFuture {
-        //             fut: Box::pin(async move {
-        //                 join_handle.await.unwrap_or_else(|e| {
-        //                     let error =
-        // InternalError::JoinError(format!("EVENT_DISPATCH join error: {:?}",
-        // e));                     error.as_response()
-        //                 })
-        //             }),
-        //         }
-        //     },
-        //
-        //     Err(e) => {
-        //         let msg = format!("EVENT_DISPATCH read failed. {:?}", e);
-        //         DispatchFuture {
-        //             fut: Box::pin(async {
-        // InternalError::Lock(msg).as_response() }),         }
-        //     },
-        // }
     }
 
     pub fn sync_send(dispatch: Arc<EventDispatch>, request: ModuleRequest) -> EventResponse {

rust-lib/flowy-document/tests/editor/doc_test.rs

@@ -1,9 +1,9 @@
 use crate::helper::*;
-use flowy_test::TestSDKBuilder;
+use flowy_test::FlowyEnv;
 
 #[test]
 fn file_create_test() {
-    let sdk = TestSDKBuilder::new().sign_up().build();
+    let sdk = FlowyEnv::setup().sdk;
     let doc_desc = create_doc(&sdk, "hello world", "flutter ❤️ rust", "123");
     dbg!(&doc_desc);
 
@@ -13,7 +13,7 @@ fn file_create_test() {
 
 #[test]
 fn file_update_text_test() {
-    let sdk = TestSDKBuilder::new().sign_up().build();
+    let sdk = FlowyEnv::setup().sdk;
     let doc_desc = create_doc(&sdk, "hello world", "flutter ❤️ rust", "");
     dbg!(&doc_desc);
 

rust-lib/flowy-document/tests/editor/helper.rs

@@ -1,4 +1,4 @@
-use flowy_test::builder::DocTestBuilder;
+use flowy_test::builder::DocTest;
 
 use flowy_document::{entities::doc::*, event::EditorEvent::*};
 use flowy_infra::uuid;
@@ -12,7 +12,7 @@ pub fn create_doc(sdk: &FlowyTestSDK, name: &str, desc: &str, text: &str) -> Doc
         text: text.to_owned(),
     };
 
-    let doc = DocTestBuilder::new(sdk.clone())
+    let doc = DocTest::new(sdk.clone())
         .event(CreateDoc)
         .request(request)
         .sync_send()
@@ -28,7 +28,7 @@ pub fn save_doc(sdk: &FlowyTestSDK, desc: &DocInfo, content: &str) {
         text: Some(content.to_owned()),
     };
 
-    let _ = DocTestBuilder::new(sdk.clone()).event(UpdateDoc).request(request).sync_send();
+    let _ = DocTest::new(sdk.clone()).event(UpdateDoc).request(request).sync_send();
 }
 
 // #[allow(dead_code)]
@@ -52,7 +52,7 @@ pub(crate) fn read_doc_data(sdk: &FlowyTestSDK, doc_id: &str, path: &str) -> Doc
         path: path.to_string(),
     };
 
-    let doc = DocTestBuilder::new(sdk.clone())
+    let doc = DocTest::new(sdk.clone())
         .event(ReadDocData)
         .request(request)
         .sync_send()

rust-lib/flowy-sdk/src/lib.rs

@@ -22,6 +22,7 @@ impl FlowySDK {
         init_log(root);
         init_kv(root);
 
+        tracing::info!("🔥 user folder: {}", root);
         let dispatch = Arc::new(init_dispatch(root));
         let root = root.to_owned();
         Self { root, dispatch }
@@ -31,7 +32,6 @@ impl FlowySDK {
 }
 
 fn init_kv(root: &str) {
-    tracing::info!("🔥 Root path: {}", root);
     match flowy_infra::kv::KV::init(root) {
         Ok(_) => {},
         Err(e) => tracing::error!("Init kv store failedL: {}", e),

rust-lib/flowy-test/src/builder.rs

@@ -5,78 +5,27 @@ use std::{
     hash::Hash,
 };
 
-use crate::helper::{create_default_workspace_if_need, login_email, login_password, random_email};
+use crate::FlowyTestSDK;
 use flowy_dispatch::prelude::*;
 use flowy_document::errors::DocError;
-pub use flowy_sdk::*;
+use flowy_sdk::*;
-use flowy_user::{
+use flowy_user::errors::UserError;
-    errors::UserError,
-    event::UserEvent::{SignOut, SignUp},
-    prelude::*,
-};
 use flowy_workspace::errors::WorkspaceError;
-use std::{marker::PhantomData, sync::Arc};
+use std::{convert::TryFrom, marker::PhantomData, sync::Arc};
 
-use crate::FlowyTestSDK;
+pub type DocTest = Builder<DocError>;
-use flowy_user::event::UserEvent::SignIn;
+impl DocTest {
-use std::convert::TryFrom;
-
-pub type DocTestBuilder = Builder<DocError>;
-impl DocTestBuilder {
     pub fn new(sdk: FlowyTestSDK) -> Self { Builder::test(TestContext::new(sdk)) }
 }
 
-pub type WorkspaceTestBuilder = Builder<WorkspaceError>;
+pub type WorkspaceTest = Builder<WorkspaceError>;
-impl WorkspaceTestBuilder {
+impl WorkspaceTest {
     pub fn new(sdk: FlowyTestSDK) -> Self { Builder::test(TestContext::new(sdk)) }
 }
 
-pub type UserTestBuilder = Builder<UserError>;
+pub type UserTest = Builder<UserError>;
-impl UserTestBuilder {
+impl UserTest {
     pub fn new(sdk: FlowyTestSDK) -> Self { Builder::test(TestContext::new(sdk)) }
-
-    pub fn sign_up(self) -> SignUpContext {
-        let password = login_password();
-        let payload = SignUpRequest {
-            email: random_email(),
-            name: "app flowy".to_string(),
-            password: password.clone(),
-        }
-        .into_bytes()
-        .unwrap();
-
-        let request = ModuleRequest::new(SignUp).payload(payload);
-        let user_detail = EventDispatch::sync_send(self.dispatch(), request)
-            .parse::<UserDetail, UserError>()
-            .unwrap()
-            .unwrap();
-
-        let _ = create_default_workspace_if_need(self.dispatch(), &user_detail.id);
-        SignUpContext { user_detail, password }
-    }
-
-    #[allow(dead_code)]
-    fn sign_in(mut self) -> Self {
-        let payload = SignInRequest {
-            email: login_email(),
-            password: login_password(),
-        }
-        .into_bytes()
-        .unwrap();
-
-        let request = ModuleRequest::new(SignIn).payload(payload);
-        let user_detail = EventDispatch::sync_send(self.dispatch(), request)
-            .parse::<UserDetail, UserError>()
-            .unwrap()
-            .unwrap();
-
-        self.user_detail = Some(user_detail);
-        self
-    }
-
-    #[allow(dead_code)]
-    fn logout(&self) { let _ = EventDispatch::sync_send(self.dispatch(), ModuleRequest::new(SignOut)); }
-
     pub fn user_detail(&self) -> &Option<UserDetail> { &self.user_detail }
 }
 
@@ -185,7 +134,3 @@ impl TestContext {
         }
     }
 }
-pub struct SignUpContext {
-    pub user_detail: UserDetail,
-    pub password: String,
-}

rust-lib/flowy-test/src/helper.rs

@@ -2,7 +2,11 @@ use bytes::Bytes;
 use flowy_dispatch::prelude::{EventDispatch, ModuleRequest, ToBytes};
 use flowy_infra::{kv::KV, uuid};
 
-use flowy_user::errors::{ErrorBuilder, ErrorCode, UserError};
+use flowy_user::{
+    entities::{SignInRequest, SignUpRequest, UserDetail},
+    errors::{ErrorBuilder, ErrorCode, UserError},
+    event::UserEvent::{SignIn, SignOut, SignUp},
+};
 use flowy_workspace::{
     entities::workspace::{CreateWorkspaceRequest, QueryWorkspaceRequest, Workspace},
     errors::WorkspaceError,
@@ -70,3 +74,49 @@ pub(crate) fn create_default_workspace_if_need(dispatch: Arc<EventDispatch>, use
 
     Ok(())
 }
+
+pub struct SignUpContext {
+    pub user_detail: UserDetail,
+    pub password: String,
+}
+
+pub fn sign_up(dispatch: Arc<EventDispatch>) -> SignUpContext {
+    let password = login_password();
+    let payload = SignUpRequest {
+        email: random_email(),
+        name: "app flowy".to_string(),
+        password: password.clone(),
+    }
+    .into_bytes()
+    .unwrap();
+
+    let request = ModuleRequest::new(SignUp).payload(payload);
+    let user_detail = EventDispatch::sync_send(dispatch.clone(), request)
+        .parse::<UserDetail, UserError>()
+        .unwrap()
+        .unwrap();
+
+    let _ = create_default_workspace_if_need(dispatch.clone(), &user_detail.id);
+    SignUpContext { user_detail, password }
+}
+
+#[allow(dead_code)]
+fn sign_in(dispatch: Arc<EventDispatch>) -> UserDetail {
+    let payload = SignInRequest {
+        email: login_email(),
+        password: login_password(),
+    }
+    .into_bytes()
+    .unwrap();
+
+    let request = ModuleRequest::new(SignIn).payload(payload);
+    let user_detail = EventDispatch::sync_send(dispatch, request)
+        .parse::<UserDetail, UserError>()
+        .unwrap()
+        .unwrap();
+
+    user_detail
+}
+
+#[allow(dead_code)]
+fn logout(dispatch: Arc<EventDispatch>) { let _ = EventDispatch::sync_send(dispatch, ModuleRequest::new(SignOut)); }

rust-lib/flowy-test/src/lib.rs

@@ -1,9 +1,9 @@
 pub mod builder;
 mod helper;
-// pub mod workspace_builder;
 
-use crate::{builder::UserTestBuilder, helper::root_dir};
+use crate::helper::*;
 use flowy_sdk::FlowySDK;
+use flowy_user::entities::UserDetail;
 
 pub mod prelude {
     pub use crate::{builder::*, helper::*, *};
@@ -13,19 +13,25 @@ pub mod prelude {
 pub type FlowyTestSDK = FlowySDK;
 
 #[derive(Clone)]
-pub struct TestSDKBuilder {
+pub struct FlowyEnv {
-    inner: FlowyTestSDK,
+    pub sdk: FlowyTestSDK,
+    pub user: UserDetail,
+    pub password: String,
 }
 
-impl TestSDKBuilder {
+impl FlowyEnv {
-    pub fn new() -> Self { Self { inner: init_test_sdk() } }
+    pub fn setup() -> Self {
-
+        let sdk = init_test_sdk();
-    pub fn sign_up(self) -> Self {
+        let result = sign_up(sdk.dispatch());
-        let _ = UserTestBuilder::new(self.inner.clone()).sign_up();
+        let env = Self {
-        self
+            sdk,
+            user: result.user_detail,
+            password: result.password,
+        };
+        env
     }
 
-    pub fn build(self) -> FlowyTestSDK { self.inner }
+    pub fn sdk(&self) -> FlowyTestSDK { self.sdk.clone() }
 }
 
 pub fn init_test_sdk() -> FlowyTestSDK {

rust-lib/flowy-test/src/workspace_builder.rs

@@ -1,60 +0,0 @@
-use super::builder::Builder;
-use crate::{builder::TestContext, helper::FlowyTestSDK};
-use flowy_workspace::{
-    entities::{app::App, view::View, workspace::*},
-    errors::WorkspaceError,
-    event::WorkspaceEvent::*,
-};
-
-pub enum WorkspaceAction {
-    CreateWorkspace(CreateWorkspaceRequest),
-    ReadWorkspace(QueryWorkspaceRequest),
-}
-
-type Inner = Builder<WorkspaceError>;
-
-pub struct WorkspaceTestBuilder {
-    workspace: Option<Workspace>,
-    app: Option<App>,
-    view: Option<View>,
-    inner: Builder<WorkspaceError>,
-}
-
-impl WorkspaceTestBuilder {
-    pub fn new(sdk: FlowyTestSDK) -> Self {
-        Self {
-            workspace: None,
-            app: None,
-            view: None,
-            inner: Builder::test(TestContext::new(sdk)),
-        }
-    }
-
-    pub fn run(mut self, actions: Vec<WorkspaceAction>) {
-        let inner = self.inner;
-        for action in actions {
-            match action {
-                WorkspaceAction::CreateWorkspace(request) => {
-                    let workspace = inner
-                        .clone()
-                        .event(CreateWorkspace)
-                        .request(request)
-                        .sync_send()
-                        .parse::<Workspace>();
-                    self.workspace = Some(workspace);
-                },
-                WorkspaceAction::ReadWorkspace(request) => {
-                    let mut repeated_workspace = inner
-                        .clone()
-                        .event(ReadWorkspaces)
-                        .request(request)
-                        .sync_send()
-                        .parse::<RepeatedWorkspace>();
-
-                    debug_assert_eq!(repeated_workspace.len(), 1, "Default workspace not found");
-                    repeated_workspace.drain(..1).collect::<Vec<Workspace>>().pop()
-                },
-            }
-        }
-    }
-}

rust-lib/flowy-user/src/services/user/user_session.rs

@@ -142,7 +142,8 @@ impl UserSession {
                     log::info!("{:?}", e);
                 },
             }
-        });
+        })
+        .await;
 
         let user = dsl::user_table
             .filter(user_table::id.eq(&session.user_id))

rust-lib/flowy-user/tests/event/auth_test.rs

@@ -1,5 +1,5 @@
 use crate::helper::*;
-use flowy_test::{builder::UserTestBuilder, init_test_sdk};
+use flowy_test::{builder::UserTest, init_test_sdk, FlowyEnv};
 use flowy_user::{errors::ErrorCode, event::UserEvent::*, prelude::*};
 use serial_test::*;
 
@@ -15,7 +15,7 @@ fn sign_up_with_invalid_email() {
         };
 
         assert_eq!(
-            UserTestBuilder::new(sdk).event(SignUp).request(request).sync_send().error().code,
+            UserTest::new(sdk).event(SignUp).request(request).sync_send().error().code,
             ErrorCode::EmailFormatInvalid
         );
     }
@@ -31,23 +31,22 @@ fn sign_up_with_invalid_password() {
             password,
         };
 
-        UserTestBuilder::new(sdk).event(SignUp).request(request).sync_send().assert_error();
+        UserTest::new(sdk).event(SignUp).request(request).sync_send().assert_error();
     }
 }
 
 #[test]
 #[serial]
 fn sign_in_success() {
-    let sdk = init_test_sdk();
+    let env = FlowyEnv::setup();
-    let context = UserTestBuilder::new(sdk.clone()).sign_up();
+    let _ = UserTest::new(env.sdk()).event(SignOut).sync_send();
-    let _ = UserTestBuilder::new(sdk.clone()).event(SignOut).sync_send();
 
     let request = SignInRequest {
-        email: context.user_detail.email,
+        email: env.user.email.clone(),
-        password: context.password,
+        password: env.password.clone(),
     };
 
-    let response = UserTestBuilder::new(sdk)
+    let response = UserTest::new(env.sdk())
         .event(SignIn)
         .request(request)
         .sync_send()
@@ -66,7 +65,7 @@ fn sign_in_with_invalid_email() {
         };
 
         assert_eq!(
-            UserTestBuilder::new(sdk).event(SignIn).request(request).sync_send().error().code,
+            UserTest::new(sdk).event(SignIn).request(request).sync_send().error().code,
             ErrorCode::EmailFormatInvalid
         );
     }
@@ -82,6 +81,6 @@ fn sign_in_with_invalid_password() {
             password,
         };
 
-        UserTestBuilder::new(sdk).event(SignIn).request(request).sync_send().assert_error();
+        UserTest::new(sdk).event(SignIn).request(request).sync_send().assert_error();
     }
 }

rust-lib/flowy-user/tests/event/user_profile_test.rs

@@ -1,6 +1,6 @@
 use crate::helper::*;
 use flowy_infra::uuid;
-use flowy_test::{builder::UserTestBuilder, init_test_sdk};
+use flowy_test::{builder::UserTest, init_test_sdk, FlowyEnv};
 use flowy_user::{errors::ErrorCode, event::UserEvent::*, prelude::*};
 use serial_test::*;
 
@@ -8,31 +8,30 @@ use serial_test::*;
 #[serial]
 fn user_profile_get_failed() {
     let sdk = init_test_sdk();
-    let result = UserTestBuilder::new(sdk).event(GetUserProfile).assert_error().sync_send();
+    let result = UserTest::new(sdk).event(GetUserProfile).assert_error().sync_send();
     assert!(result.user_detail().is_none())
 }
 
 #[test]
 #[serial]
 fn user_profile_get() {
-    let sdk = init_test_sdk();
+    let env = FlowyEnv::setup();
-    let user_detail = UserTestBuilder::new(sdk.clone()).sign_up().user_detail;
+    let user = UserTest::new(env.sdk.clone())
-
+        .event(GetUserProfile)
-    let user_detail2 = UserTestBuilder::new(sdk).event(GetUserProfile).sync_send().parse::<UserDetail>();
+        .sync_send()
-
+        .parse::<UserDetail>();
-    assert_eq!(user_detail, user_detail2);
+    assert_eq!(env.user, user);
 }
 
 #[test]
 #[serial]
 fn user_update_with_name() {
-    let sdk = init_test_sdk();
+    let env = FlowyEnv::setup();
-    let user_detail = UserTestBuilder::new(sdk.clone()).sign_up().user_detail;
     let new_name = "hello_world".to_owned();
-    let request = UpdateUserRequest::new(&user_detail.id).name(&new_name);
+    let request = UpdateUserRequest::new(&env.user.id).name(&new_name);
-    let _ = UserTestBuilder::new(sdk.clone()).event(UpdateUser).request(request).sync_send();
+    let _ = UserTest::new(env.sdk()).event(UpdateUser).request(request).sync_send();
 
-    let user_detail = UserTestBuilder::new(sdk)
+    let user_detail = UserTest::new(env.sdk())
         .event(GetUserProfile)
         .assert_error()
         .sync_send()
@@ -44,14 +43,11 @@ fn user_update_with_name() {
 #[test]
 #[serial]
 fn user_update_with_email() {
-    let sdk = init_test_sdk();
+    let env = FlowyEnv::setup();
-    let user_detail = UserTestBuilder::new(sdk.clone()).sign_up().user_detail;
     let new_email = format!("{}@gmai.com", uuid());
-    let request = UpdateUserRequest::new(&user_detail.id).email(&new_email);
+    let request = UpdateUserRequest::new(&env.user.id).email(&new_email);
-
+    let _ = UserTest::new(env.sdk()).event(UpdateUser).request(request).sync_send();
-    let _ = UserTestBuilder::new(sdk.clone()).event(UpdateUser).request(request).sync_send();
+    let user_detail = UserTest::new(env.sdk())
-
-    let user_detail = UserTestBuilder::new(sdk)
         .event(GetUserProfile)
         .assert_error()
         .sync_send()
@@ -63,12 +59,11 @@ fn user_update_with_email() {
 #[test]
 #[serial]
 fn user_update_with_password() {
-    let sdk = init_test_sdk();
+    let env = FlowyEnv::setup();
-    let user_detail = UserTestBuilder::new(sdk.clone()).sign_up().user_detail;
     let new_password = "H123world!".to_owned();
-    let request = UpdateUserRequest::new(&user_detail.id).password(&new_password);
+    let request = UpdateUserRequest::new(&env.user.id).password(&new_password);
 
-    let _ = UserTestBuilder::new(sdk)
+    let _ = UserTest::new(env.sdk())
         .event(UpdateUser)
         .request(request)
         .sync_send()
@@ -78,17 +73,11 @@ fn user_update_with_password() {
 #[test]
 #[serial]
 fn user_update_with_invalid_email() {
-    let sdk = init_test_sdk();
+    let env = FlowyEnv::setup();
-    let user_detail = UserTestBuilder::new(sdk.clone()).sign_up().user_detail;
     for email in invalid_email_test_case() {
-        let request = UpdateUserRequest::new(&user_detail.id).email(&email);
+        let request = UpdateUserRequest::new(&env.user.id).email(&email);
         assert_eq!(
-            UserTestBuilder::new(sdk.clone())
+            UserTest::new(env.sdk()).event(UpdateUser).request(request).sync_send().error().code,
-                .event(UpdateUser)
-                .request(request)
-                .sync_send()
-                .error()
-                .code,
             ErrorCode::EmailFormatInvalid
         );
     }
@@ -97,12 +86,11 @@ fn user_update_with_invalid_email() {
 #[test]
 #[serial]
 fn user_update_with_invalid_password() {
-    let sdk = init_test_sdk();
+    let env = FlowyEnv::setup();
-    let user_detail = UserTestBuilder::new(sdk.clone()).sign_up().user_detail;
     for password in invalid_password_test_case() {
-        let request = UpdateUserRequest::new(&user_detail.id).password(&password);
+        let request = UpdateUserRequest::new(&env.user.id).password(&password);
 
-        UserTestBuilder::new(sdk.clone())
+        UserTest::new(env.sdk())
             .event(UpdateUser)
             .request(request)
             .sync_send()
@@ -113,11 +101,9 @@ fn user_update_with_invalid_password() {
 #[test]
 #[serial]
 fn user_update_with_invalid_name() {
-    let sdk = init_test_sdk();
+    let env = FlowyEnv::setup();
-    let user_detail = UserTestBuilder::new(sdk.clone()).sign_up().user_detail;
+    let request = UpdateUserRequest::new(&env.user.id).name("");
-    let request = UpdateUserRequest::new(&user_detail.id).name("");
+    UserTest::new(env.sdk())
-
-    UserTestBuilder::new(sdk)
         .event(UpdateUser)
         .request(request)
         .sync_send()

rust-lib/flowy-workspace/tests/workspace/app_test.rs

@@ -8,7 +8,7 @@ use flowy_workspace::entities::{
 
 #[test]
 fn app_create() {
-    let sdk = TestSDKBuilder::new().sign_up().build();
+    let sdk = FlowyEnv::setup().sdk;
     let workspace = create_workspace(&sdk, "Workspace", "");
     let app = create_app(&sdk, "App A", "AppFlowy Github Project", &workspace.id);
     dbg!(&app);
@@ -17,7 +17,7 @@ fn app_create() {
 #[test]
 #[should_panic]
 fn app_delete() {
-    let sdk = TestSDKBuilder::new().sign_up().build();
+    let sdk = FlowyEnv::setup().sdk;
     let workspace = create_workspace(&sdk, "Workspace", "");
     let app = create_app(&sdk, "App A", "AppFlowy Github Project", &workspace.id);
     delete_app(&sdk, &app.id);
@@ -27,7 +27,7 @@ fn app_delete() {
 
 #[test]
 fn app_read() {
-    let sdk = TestSDKBuilder::new().sign_up().build();
+    let sdk = FlowyEnv::setup().sdk;
 
     let workspace = create_workspace(&sdk, "Workspace", "");
     let app = create_app(&sdk, "App A", "AppFlowy Github Project", &workspace.id);
@@ -38,7 +38,7 @@ fn app_read() {
 
 #[test]
 fn app_create_with_view() {
-    let sdk = TestSDKBuilder::new().sign_up().build();
+    let sdk = FlowyEnv::setup().sdk;
     let workspace = create_workspace(&sdk, "Workspace", "");
     let app = create_app(&sdk, "App A", "AppFlowy Github Project", &workspace.id);
     let request_a = CreateViewRequest {
@@ -69,7 +69,7 @@ fn app_create_with_view() {
 
 #[test]
 fn app_set_trash_flag() {
-    let sdk = TestSDKBuilder::new().sign_up().build();
+    let sdk = FlowyEnv::setup().sdk;
     let app_id = create_app_with_trash_flag(&sdk);
     let query = QueryAppRequest::new(&app_id).set_is_trash(true);
     let _ = read_app(&sdk, query);
@@ -78,7 +78,7 @@ fn app_set_trash_flag() {
 #[test]
 #[should_panic]
 fn app_set_trash_flag_2() {
-    let sdk = TestSDKBuilder::new().sign_up().build();
+    let sdk = FlowyEnv::setup().sdk;
     let app_id = create_app_with_trash_flag(&sdk);
     let query = QueryAppRequest::new(&app_id);
     let _ = read_app(&sdk, query);

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

@@ -17,7 +17,7 @@ pub fn create_workspace(sdk: &FlowyTestSDK, name: &str, desc: &str) -> Workspace
         desc: desc.to_owned(),
     };
 
-    let workspace = WorkspaceTestBuilder::new(sdk.clone())
+    let workspace = WorkspaceTest::new(sdk.clone())
         .event(CreateWorkspace)
         .request(request)
         .sync_send()
@@ -26,7 +26,7 @@ pub fn create_workspace(sdk: &FlowyTestSDK, name: &str, desc: &str) -> Workspace
 }
 
 pub fn read_workspaces(sdk: &FlowyTestSDK, request: QueryWorkspaceRequest) -> Option<Workspace> {
-    let mut repeated_workspace = WorkspaceTestBuilder::new(sdk.clone())
+    let mut repeated_workspace = WorkspaceTest::new(sdk.clone())
         .event(ReadWorkspaces)
         .request(request)
         .sync_send()
@@ -44,7 +44,7 @@ pub fn create_app(sdk: &FlowyTestSDK, name: &str, desc: &str, workspace_id: &str
         color_style: Default::default(),
     };
 
-    let app = WorkspaceTestBuilder::new(sdk.clone())
+    let app = WorkspaceTest::new(sdk.clone())
         .event(CreateApp)
         .request(create_app_request)
         .sync_send()
@@ -57,18 +57,18 @@ pub fn delete_app(sdk: &FlowyTestSDK, app_id: &str) {
         app_id: app_id.to_string(),
     };
 
-    WorkspaceTestBuilder::new(sdk.clone())
+    WorkspaceTest::new(sdk.clone())
         .event(DeleteApp)
         .request(delete_app_request)
         .sync_send();
 }
 
 pub fn update_app(sdk: &FlowyTestSDK, request: UpdateAppRequest) {
-    WorkspaceTestBuilder::new(sdk.clone()).event(UpdateApp).request(request).sync_send();
+    WorkspaceTest::new(sdk.clone()).event(UpdateApp).request(request).sync_send();
 }
 
 pub fn read_app(sdk: &FlowyTestSDK, request: QueryAppRequest) -> App {
-    let app = WorkspaceTestBuilder::new(sdk.clone())
+    let app = WorkspaceTest::new(sdk.clone())
         .event(ReadApp)
         .request(request)
         .sync_send()
@@ -78,7 +78,7 @@ pub fn read_app(sdk: &FlowyTestSDK, request: QueryAppRequest) -> App {
 }
 
 pub fn create_view_with_request(sdk: &FlowyTestSDK, request: CreateViewRequest) -> View {
-    let view = WorkspaceTestBuilder::new(sdk.clone())
+    let view = WorkspaceTest::new(sdk.clone())
         .event(CreateView)
         .request(request)
         .sync_send()
@@ -101,14 +101,11 @@ pub fn create_view(sdk: &FlowyTestSDK, workspace_id: &str) -> View {
 }
 
 pub fn update_view(sdk: &FlowyTestSDK, request: UpdateViewRequest) {
-    WorkspaceTestBuilder::new(sdk.clone())
+    WorkspaceTest::new(sdk.clone()).event(UpdateView).request(request).sync_send();
-        .event(UpdateView)
-        .request(request)
-        .sync_send();
 }
 
 pub fn read_view(sdk: &FlowyTestSDK, request: QueryViewRequest) -> View {
-    WorkspaceTestBuilder::new(sdk.clone())
+    WorkspaceTest::new(sdk.clone())
         .event(ReadView)
         .request(request)
         .sync_send()

rust-lib/flowy-workspace/tests/workspace/view_test.rs

@@ -1,18 +1,18 @@
 use crate::helper::*;
 
-use flowy_test::{FlowyTestSDK, TestSDKBuilder};
+use flowy_test::{FlowyEnv, FlowyTestSDK};
 use flowy_workspace::entities::view::*;
 
 #[test]
 fn view_create() {
-    let sdk = TestSDKBuilder::new().sign_up().build();
+    let sdk = FlowyEnv::setup().sdk;
     let workspace = create_workspace(&sdk, "Workspace", "");
     let _ = create_view(&sdk, &workspace.id);
 }
 
 #[test]
 fn view_set_trash_flag() {
-    let sdk = TestSDKBuilder::new().sign_up().build();
+    let sdk = FlowyEnv::setup().sdk;
     let view_id = create_view_with_trash_flag(&sdk);
     let query = QueryViewRequest::new(&view_id).set_is_trash(true);
     let _ = read_view(&sdk, query);
@@ -21,7 +21,7 @@ fn view_set_trash_flag() {
 #[test]
 #[should_panic]
 fn view_set_trash_flag2() {
-    let sdk = TestSDKBuilder::new().sign_up().build();
+    let sdk = FlowyEnv::setup().sdk;
 
     let view_id = create_view_with_trash_flag(&sdk);
     let query = QueryViewRequest::new(&view_id);

rust-lib/flowy-workspace/tests/workspace/workspace_test.rs

@@ -1,5 +1,5 @@
 use crate::helper::*;
-use flowy_test::{builder::*, TestSDKBuilder};
+use flowy_test::{builder::*, FlowyEnv};
 use flowy_workspace::{
     entities::workspace::{CreateWorkspaceRequest, QueryWorkspaceRequest, RepeatedWorkspace},
     event::WorkspaceEvent::*,
@@ -8,16 +8,16 @@ use flowy_workspace::{
 
 #[test]
 fn workspace_create_success() {
-    let sdk = TestSDKBuilder::new().sign_up().build();
+    let sdk = FlowyEnv::setup().sdk;
     let _ = create_workspace(&sdk, "First workspace", "");
 }
 
 #[test]
 fn workspace_read_all() {
-    let sdk = TestSDKBuilder::new().sign_up().build();
+    let sdk = FlowyEnv::setup().sdk;
     let _ = create_workspace(&sdk, "Workspace A", "workspace_create_and_then_get_workspace_success");
 
-    let workspaces = WorkspaceTestBuilder::new(sdk.clone())
+    let workspaces = WorkspaceTest::new(sdk.clone())
         .event(ReadWorkspaces)
         .request(QueryWorkspaceRequest::new())
         .sync_send()
@@ -28,7 +28,7 @@ fn workspace_read_all() {
 
 #[test]
 fn workspace_create_and_then_get_workspace() {
-    let sdk = TestSDKBuilder::new().sign_up().build();
+    let sdk = FlowyEnv::setup().sdk;
     let workspace = create_workspace(&sdk, "Workspace A", "workspace_create_and_then_get_workspace_success");
     let request = QueryWorkspaceRequest::new().workspace_id(&workspace.id);
     let workspace_from_db = read_workspaces(&sdk, request).unwrap();
@@ -37,7 +37,7 @@ fn workspace_create_and_then_get_workspace() {
 
 #[test]
 fn workspace_create_with_apps() {
-    let sdk = TestSDKBuilder::new().sign_up().build();
+    let sdk = FlowyEnv::setup().sdk;
     let workspace = create_workspace(&sdk, "Workspace", "");
     let app = create_app(&sdk, "App A", "AppFlowy Github Project", &workspace.id);
 
@@ -48,12 +48,11 @@ fn workspace_create_with_apps() {
 
 #[test]
 fn workspace_create_with_invalid_name() {
-    let sdk = TestSDKBuilder::new().sign_up().build();
     for name in invalid_workspace_name_test_case() {
-        let _ = UserTestBuilder::new(sdk.clone()).sign_up();
+        let sdk = FlowyEnv::setup().sdk;
         let request = CreateWorkspaceRequest { name, desc: "".to_owned() };
         assert_eq!(
-            WorkspaceTestBuilder::new(sdk.clone())
+            WorkspaceTest::new(sdk)
                 .event(CreateWorkspace)
                 .request(request)
                 .sync_send()
@@ -66,11 +65,11 @@ fn workspace_create_with_invalid_name() {
 
 #[test]
 fn workspace_update_with_invalid_name() {
-    let sdk = TestSDKBuilder::new().sign_up().build();
+    let sdk = FlowyEnv::setup().sdk;
     for name in invalid_workspace_name_test_case() {
         let request = CreateWorkspaceRequest { name, desc: "".to_owned() };
         assert_eq!(
-            WorkspaceTestBuilder::new(sdk.clone())
+            WorkspaceTest::new(sdk.clone())
                 .event(CreateWorkspace)
                 .request(request)
                 .sync_send()