chore: delete/create filter

frontend/rust-lib/flowy-grid/tests/grid/script.rs

@@ -2,6 +2,7 @@ use bytes::Bytes;
 use flowy_grid::services::field::*;
 use flowy_grid::services::grid_editor::{GridPadBuilder, GridRevisionEditor};
 use flowy_grid::services::row::CreateRowRevisionPayload;
+use flowy_grid::services::setting::GridSettingChangesetBuilder;
 use flowy_grid_data_model::entities::*;
 use flowy_grid_data_model::revision::*;
 use flowy_revision::REVISION_WRITE_INTERVAL_IN_MILLIS;
@@ -66,8 +67,17 @@ pub enum EditorScript {
     UpdateGridSetting {
         params: GridSettingChangesetParams,
     },
+    InsertGridTableFilter {
+        payload: CreateGridFilterPayload,
+    },
+    AssertTableFilterCount {
+        count: i32,
+    },
+    DeleteGridTableFilter {
+        filter_id: String,
+    },
     AssertGridSetting {
-        expected_setting: GridSettingRevision,
+        expected_setting: GridSetting,
     },
     AssertGridRevisionPad,
 }
@@ -239,6 +249,26 @@ impl GridEditorTest {
             EditorScript::UpdateGridSetting { params } => {
                 let _ = self.editor.update_grid_setting(params).await.unwrap();
             }
+            EditorScript::InsertGridTableFilter { payload } => {
+                let params: CreateGridFilterParams = payload.try_into().unwrap();
+                let layout_type = GridLayoutType::Table;
+                let params = GridSettingChangesetBuilder::new(&self.grid_id, &layout_type)
+                    .insert_filter(params)
+                    .build();
+                let _ = self.editor.update_grid_setting(params).await.unwrap();
+            }
+            EditorScript::AssertTableFilterCount { count } => {
+                let layout_type = GridLayoutType::Table;
+                let filters = self.editor.get_grid_filter(&layout_type).await.unwrap();
+                assert_eq!(count as usize, filters.len());
+            }
+            EditorScript::DeleteGridTableFilter { filter_id } => {
+                let layout_type = GridLayoutType::Table;
+                let params = GridSettingChangesetBuilder::new(&self.grid_id, &layout_type)
+                    .delete_filter(&filter_id)
+                    .build();
+                let _ = self.editor.update_grid_setting(params).await.unwrap();
+            }
             EditorScript::AssertGridSetting { expected_setting } => {
                 let setting = self.editor.get_grid_setting().await.unwrap();
                 assert_eq!(expected_setting, setting);
@@ -262,8 +292,18 @@ impl GridEditorTest {
             .row_revs
     }
 
-    pub(crate) async fn get_grid_setting(&self) -> GridSettingRevision {
-        self.editor.get_grid_setting().await.unwrap()
+    pub async fn grid_filters(&self) -> Vec<GridFilter> {
+        let layout_type = GridLayoutType::Table;
+        self.editor.get_grid_filter(&layout_type).await.unwrap()
+    }
+
+    pub fn text_field(&self) -> &FieldRevision {
+        self.field_revs
+            .iter()
+            .filter(|field_rev| field_rev.field_type == FieldType::RichText)
+            .collect::<Vec<_>>()
+            .pop()
+            .unwrap()
     }
 }
 

frontend/rust-lib/flowy-grid/tests/grid/setting_test.rs

@@ -1,29 +1,72 @@
 use crate::grid::script::EditorScript::*;
 use crate::grid::script::*;
+
 use flowy_grid_data_model::entities::{
-    CreateGridFilterParams, CreateGridFilterPayload, GridLayoutType, GridSettingChangesetParams,
+    CreateGridFilterParams, CreateGridFilterPayload, GridLayoutType, GridSettingChangesetParams, TextFilterCondition,
 };
-use flowy_grid_data_model::revision::GridSettingRevision;
 
 #[tokio::test]
-async fn grid_setting_create_filter_test() {
+async fn grid_setting_create_text_filter_test() {
     let test = GridEditorTest::new().await;
+    let field_rev = test.text_field();
+    let condition = TextFilterCondition::TextIsEmpty as i32;
 
-    let layout_type = GridLayoutType::Table;
-    let field_rev = test.field_revs.last().unwrap();
-    let create_params: CreateGridFilterParams = CreateGridFilterPayload {
-        field_id: field_rev.id.clone(),
-        field_type: field_rev.field_type.clone(),
-    }
-    .try_into()
-    .unwrap();
-    let params = GridSettingChangesetParams::from_insert_filter(&test.grid_id, layout_type, create_params);
-
-    let scripts = vec![UpdateGridSetting { params }];
+    let scripts = vec![
+        InsertGridTableFilter {
+            payload: CreateGridFilterPayload {
+                field_id: field_rev.id.clone(),
+                field_type: field_rev.field_type.clone(),
+                condition,
+                content: Some("abc".to_owned()),
+            },
+        },
+        AssertTableFilterCount { count: 1 },
+    ];
     GridEditorTest::new().await.run_scripts(scripts).await;
-
-    // let mut expected_grid_setting = test.get_grid_setting().await;
 }
 
+#[tokio::test]
+#[should_panic]
+async fn grid_setting_create_text_filter_panic_test() {
+    let test = GridEditorTest::new().await;
+    let field_rev = test.text_field();
+    let scripts = vec![InsertGridTableFilter {
+        payload: CreateGridFilterPayload {
+            field_id: field_rev.id.clone(),
+            field_type: field_rev.field_type.clone(),
+            condition: 20, // Invalid condition type
+            content: Some("abc".to_owned()),
+        },
+    }];
+    GridEditorTest::new().await.run_scripts(scripts).await;
+}
+
+#[tokio::test]
+async fn grid_setting_delete_text_filter_test() {
+    let mut test = GridEditorTest::new().await;
+    let field_rev = test.text_field();
+    let condition = TextFilterCondition::TextIsEmpty as i32;
+
+    let scripts = vec![
+        InsertGridTableFilter {
+            payload: CreateGridFilterPayload {
+                field_id: field_rev.id.clone(),
+                field_type: field_rev.field_type.clone(),
+                condition,
+                content: Some("abc".to_owned()),
+            },
+        },
+        AssertTableFilterCount { count: 1 },
+    ];
+
+    test.run_scripts(scripts).await;
+    let filter = test.grid_filters().await.pop().unwrap();
+
+    test.run_scripts(vec![
+        DeleteGridTableFilter { filter_id: filter.id },
+        AssertTableFilterCount { count: 0 },
+    ])
+    .await;
+}
 #[tokio::test]
 async fn grid_setting_sort_test() {}