chore: add 5 rows in test grid

frontend/rust-lib/flowy-grid/tests/grid/block_test/row_test.rs

@@ -79,8 +79,8 @@ async fn grid_row_add_cells_test() {
         |options| options,
         &vec![GOOGLE, FACEBOOK, TWITTER].join(SELECTION_IDS_SEPARATOR),
     );
-
-    test.run_scripts(builder.build()).await;
+    let scripts = builder.build();
+    test.run_scripts(scripts).await;
 }
 
 #[tokio::test]
@@ -89,7 +89,8 @@ async fn grid_row_insert_number_test() {
     for (val, expected) in &[("1647251762", "2022/03/14"), ("2022/03/14", ""), ("", "")] {
         let mut builder = CreateRowScriptBuilder::new(&test);
         builder.insert(FieldType::DateTime, val, expected);
-        test.run_scripts(builder.build()).await;
+        let scripts = builder.build();
+        test.run_scripts(scripts).await;
     }
 }
 
@@ -105,7 +106,8 @@ async fn grid_row_insert_date_test() {
     ] {
         let mut builder = CreateRowScriptBuilder::new(&test);
         builder.insert(FieldType::Number, val, expected);
-        test.run_scripts(builder.build()).await;
+        let scripts = builder.build();
+        test.run_scripts(scripts).await;
     }
 }
 #[tokio::test]
@@ -113,7 +115,8 @@ async fn grid_row_insert_single_select_test() {
     let mut test = GridRowTest::new().await;
     let mut builder = CreateRowScriptBuilder::new(&test);
     builder.insert_single_select_cell(|mut options| options.pop().unwrap(), PAUSED);
-    test.run_scripts(builder.build()).await;
+    let scripts = builder.build();
+    test.run_scripts(scripts).await;
 }
 
 #[tokio::test]
@@ -127,6 +130,6 @@ async fn grid_row_insert_multi_select_test() {
         },
         &vec![FACEBOOK, TWITTER].join(SELECTION_IDS_SEPARATOR),
     );
-
-    test.run_scripts(builder.build()).await;
+    let scripts = builder.build();
+    test.run_scripts(scripts).await;
 }

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

@@ -2,13 +2,9 @@ use crate::grid::block_test::script::RowScript::{AssertCell, CreateRow};
 use crate::grid::block_test::util::GridRowTestBuilder;
 use crate::grid::grid_editor::GridEditorTest;
 use flowy_grid::entities::{CellIdentifier, FieldType, RowInfo};
-use flowy_grid::services::field::{
-    CheckboxCellDataParser, DateCellDataParser, MultiSelectTypeOption, NumberCellDataParser, NumberTypeOption,
-    SelectOption, SelectOptionCellDataParser, SelectOptionIdsParser, SingleSelectTypeOption, TextCellDataParser,
-    URLCellDataParser, SELECTION_IDS_SEPARATOR,
-};
+use flowy_grid::services::field::*;
 use flowy_grid_data_model::revision::{
-    FieldRevision, GridBlockMetaRevision, GridBlockMetaRevisionChangeset, RowMetaChangeset, RowRevision,
+    GridBlockMetaRevision, GridBlockMetaRevisionChangeset, RowMetaChangeset, RowRevision,
 };
 use std::collections::HashMap;
 use std::sync::Arc;
@@ -74,19 +70,7 @@ impl GridRowTest {
     }
 
     pub fn row_builder(&self) -> GridRowTestBuilder {
-        let field_revs_ref = self
-            .field_revs
-            .iter()
-            .map(|field_rev| field_rev.as_ref())
-            .collect::<Vec<&FieldRevision>>();
-        GridRowTestBuilder::new(
-            self.block_id(),
-            &self
-                .field_revs
-                .iter()
-                .map(|field_rev| field_rev.as_ref())
-                .collect::<Vec<&FieldRevision>>(),
-        )
+        GridRowTestBuilder::new(self.block_id(), &self.field_revs)
     }
 
     pub async fn run_script(&mut self, script: RowScript) {

frontend/rust-lib/flowy-grid/tests/grid/block_test/util.rs

@@ -1,4 +1,5 @@
 use flowy_grid::entities::FieldType;
+use std::sync::Arc;
 
 use flowy_grid::services::field::{
     DateCellChangeset, MultiSelectTypeOption, SelectOption, SingleSelectTypeOption, SELECTION_IDS_SEPARATOR,
@@ -10,12 +11,12 @@ use strum::EnumCount;
 
 pub struct GridRowTestBuilder<'a> {
     block_id: String,
-    field_revs: &'a [&'a FieldRevision],
+    field_revs: &'a [Arc<FieldRevision>],
     inner_builder: RowRevisionBuilder<'a>,
 }
 
 impl<'a> GridRowTestBuilder<'a> {
-    pub fn new(block_id: &str, field_revs: &'a [&'a FieldRevision]) -> Self {
+    pub fn new(block_id: &str, field_revs: &'a [Arc<FieldRevision>]) -> Self {
         assert_eq!(field_revs.len(), FieldType::COUNT);
         let inner_builder = RowRevisionBuilder::new(field_revs);
         Self {
@@ -68,16 +69,15 @@ impl<'a> GridRowTestBuilder<'a> {
         url_field.id.clone()
     }
 
-    #[allow(dead_code)]
     pub fn insert_single_select_cell<F>(&mut self, f: F) -> String
     where
-        F: Fn(&Vec<SelectOption>) -> &SelectOption,
+        F: Fn(Vec<SelectOption>) -> SelectOption,
     {
         let single_select_field = self.field_rev_with_type(&FieldType::SingleSelect);
         let type_option = SingleSelectTypeOption::from(&single_select_field);
-        let option = f(&type_option.options);
+        let option = f(type_option.options);
         self.inner_builder
-            .insert_select_option_cell(&single_select_field.id, option.id.clone())
+            .insert_select_option_cell(&single_select_field.id, option.id)
             .unwrap();
 
         single_select_field.id.clone()
@@ -85,11 +85,11 @@ impl<'a> GridRowTestBuilder<'a> {
 
     pub fn insert_multi_select_cell<F>(&mut self, f: F) -> String
     where
-        F: Fn(&Vec<SelectOption>) -> &Vec<SelectOption>,
+        F: Fn(Vec<SelectOption>) -> Vec<SelectOption>,
     {
         let multi_select_field = self.field_rev_with_type(&FieldType::MultiSelect);
         let type_option = MultiSelectTypeOption::from(&multi_select_field);
-        let options = f(&type_option.options);
+        let options = f(type_option.options);
         let ops_ids = options
             .iter()
             .map(|option| option.id.clone())

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

@@ -1,6 +1,7 @@
 #![allow(clippy::all)]
 #![allow(dead_code)]
 #![allow(unused_imports)]
+use crate::grid::block_test::util::GridRowTestBuilder;
 use bytes::Bytes;
 use flowy_grid::entities::*;
 use flowy_grid::services::field::SelectOption;
@@ -158,7 +159,7 @@ fn make_test_grid() -> BuildGridContext {
             FieldType::Checkbox => {
                 // Checkbox
                 let checkbox = CheckboxTypeOptionBuilder::default();
-                let checkbox_field = FieldBuilder::new(checkbox).name("is done").visibility(true).build();
+                let checkbox_field = FieldBuilder::new(checkbox).name("is urgent").visibility(true).build();
                 grid_builder.add_field(checkbox_field);
             }
             FieldType::URL => {
@@ -171,24 +172,87 @@ fn make_test_grid() -> BuildGridContext {
     }
 
     // We have many assumptions base on the number of the rows, so do not change the number of the loop.
-    for _i in 0..10 {
-        for field_type in FieldType::iter() {
-            let field_type: FieldType = field_type;
-            // let mut row_builder = RowRevisionBuilder::new()
-            match field_type {
-                FieldType::RichText => {}
-                FieldType::Number => {}
-                FieldType::DateTime => {}
-                FieldType::SingleSelect => {}
-                FieldType::MultiSelect => {}
-                FieldType::Checkbox => {}
-                FieldType::URL => {}
+    for i in 0..5 {
+        let block_id = grid_builder.block_id().to_owned();
+        let field_revs = grid_builder.field_revs();
+        let mut row_builder = GridRowTestBuilder::new(&block_id, field_revs);
+        match i {
+            0 => {
+                for field_type in FieldType::iter() {
+                    match field_type {
+                        FieldType::RichText => row_builder.insert_text_cell("A"),
+                        FieldType::Number => row_builder.insert_number_cell("1"),
+                        FieldType::DateTime => row_builder.insert_date_cell("1647251762"),
+                        FieldType::SingleSelect => {
+                            row_builder.insert_single_select_cell(|mut options| options.remove(0))
+                        }
+                        FieldType::Checkbox => row_builder.insert_checkbox_cell("true"),
+                        _ => "".to_owned(),
+                    };
+                }
             }
+            1 => {
+                for field_type in FieldType::iter() {
+                    match field_type {
+                        FieldType::RichText => row_builder.insert_text_cell("B"),
+                        FieldType::Number => row_builder.insert_number_cell("2"),
+                        FieldType::DateTime => row_builder.insert_date_cell("1647251762"),
+                        FieldType::SingleSelect => {
+                            row_builder.insert_single_select_cell(|mut options| options.remove(0))
+                        }
+                        FieldType::Checkbox => row_builder.insert_checkbox_cell("true"),
+                        _ => "".to_owned(),
+                    };
+                }
+            }
+            2 => {
+                for field_type in FieldType::iter() {
+                    match field_type {
+                        FieldType::RichText => row_builder.insert_text_cell("C"),
+                        FieldType::Number => row_builder.insert_number_cell("3"),
+                        FieldType::DateTime => row_builder.insert_date_cell("1647251762"),
+                        FieldType::SingleSelect => {
+                            row_builder.insert_single_select_cell(|mut options| options.remove(1))
+                        }
+                        FieldType::Checkbox => row_builder.insert_checkbox_cell("false"),
+                        _ => "".to_owned(),
+                    };
+                }
+            }
+            3 => {
+                for field_type in FieldType::iter() {
+                    match field_type {
+                        FieldType::RichText => row_builder.insert_text_cell("D"),
+                        FieldType::Number => row_builder.insert_number_cell("4"),
+                        FieldType::DateTime => row_builder.insert_date_cell("1647251762"),
+                        FieldType::SingleSelect => {
+                            row_builder.insert_single_select_cell(|mut options| options.remove(1))
+                        }
+                        FieldType::Checkbox => row_builder.insert_checkbox_cell("false"),
+                        _ => "".to_owned(),
+                    };
+                }
+            }
+            4 => {
+                for field_type in FieldType::iter() {
+                    match field_type {
+                        FieldType::RichText => row_builder.insert_text_cell("E"),
+                        FieldType::Number => row_builder.insert_number_cell("5"),
+                        FieldType::DateTime => row_builder.insert_date_cell("1647251762"),
+                        FieldType::SingleSelect => {
+                            row_builder.insert_single_select_cell(|mut options| options.remove(2))
+                        }
+
+                        FieldType::Checkbox => row_builder.insert_checkbox_cell("false"),
+                        _ => "".to_owned(),
+                    };
+                }
+            }
+            _ => {}
         }
+
+        let row_rev = row_builder.build();
+        grid_builder.add_row(row_rev);
     }
-    // assert_eq!(row_revs.len(), 10);
-    //     .add_empty_row()
-    //     .add_empty_row()
-    //     .add_empty_row()
     grid_builder.build()
 }