Create test template (#1594)

* refactor: rename functions

* chore: create test templagte

Co-authored-by: nathan <[email protected]>

Author: appflowy

frontend/app_flowy/lib/plugins/grid/application/cell/cell_service/cell_service.dart

@@ -38,7 +38,7 @@ class CellService {
       ..gridId = cellId.gridId
       ..fieldId = cellId.fieldId
       ..rowId = cellId.rowId
-      ..content = data;
+      ..typeCellData = data;
     return GridEventUpdateCell(payload).send();
   }
 

frontend/rust-lib/flowy-grid/src/entities/cell_entities.rs

@@ -139,15 +139,15 @@ pub struct CellChangesetPB {
     pub field_id: String,
 
     #[pb(index = 4)]
-    pub content: String,
+    pub type_cell_data: String,
 }
 
 impl std::convert::From<CellChangesetPB> for RowChangeset {
     fn from(changeset: CellChangesetPB) -> Self {
         let mut cell_by_field_id = HashMap::with_capacity(1);
         let field_id = changeset.field_id;
         let cell_rev = CellRevision {
-            data: changeset.content,
+            type_cell_data: changeset.type_cell_data,
         };
         cell_by_field_id.insert(field_id, cell_rev);
 

frontend/rust-lib/flowy-grid/src/event_handler.rs

@@ -378,7 +378,7 @@ pub(crate) async fn update_select_option_handler(
                     grid_id: changeset.cell_identifier.view_id,
                     row_id: changeset.cell_identifier.row_id,
                     field_id: changeset.cell_identifier.field_id.clone(),
-                    content: cell_content_changeset,
+                    type_cell_data: cell_content_changeset,
                 };
                 let cloned_editor = editor.clone();
                 tokio::spawn(async move {
@@ -413,12 +413,12 @@ pub(crate) async fn get_select_option_handler(
             let type_option = select_type_option_from_field_rev(&field_rev)?;
             let type_cell_data: TypeCellData = match cell_rev {
                 None => TypeCellData {
-                    data: "".to_string(),
+                    cell_str: "".to_string(),
                     field_type: field_rev.ty.into(),
                 },
                 Some(cell_rev) => cell_rev.try_into()?,
             };
-            let ids = SelectOptionIds::from_cell_str(&type_cell_data.data)?;
+            let ids = SelectOptionIds::from_cell_str(&type_cell_data.cell_str)?;
             let selected_options = type_option.get_selected_options(ids);
             data_result(selected_options)
         }

frontend/rust-lib/flowy-grid/src/services/cell/cell_operation.rs

@@ -24,7 +24,7 @@ pub trait CellComparable {
 /// Decode the opaque cell data into readable format content
 pub trait CellDataDecoder: TypeOption {
     ///
-    /// Tries to decode the opaque cell data to `decoded_field_type`. Sometimes, the `field_type`
+    /// Tries to decode the opaque cell string to `decoded_field_type`'s cell data. Sometimes, the `field_type`
     /// of the `FieldRevision` is not equal to the `decoded_field_type`(This happened When switching
     /// the field type of the `FieldRevision` to another field type). So the cell data is need to do
     /// some transformation.
@@ -35,9 +35,9 @@ pub trait CellDataDecoder: TypeOption {
     /// data that can be parsed by the current field type. One approach is to transform the cell data
     /// when it get read. For the moment, the cell data is a string, `Yes` or `No`. It needs to compare
     /// with the option's name, if match return the id of the option.
-    fn decode_cell_data(
+    fn decode_cell_str(
         &self,
-        cell_data: String,
+        cell_str: String,
         decoded_field_type: &FieldType,
         field_rev: &FieldRevision,
     ) -> FlowyResult<<Self as TypeOption>::CellData>;
@@ -94,8 +94,8 @@ pub fn decode_type_cell_data<T: TryInto<TypeCellData, Error = FlowyError> + Debu
     let to_field_type = field_rev.ty.into();
     match data.try_into() {
         Ok(type_cell_data) => {
-            let TypeCellData { data, field_type } = type_cell_data;
-            match try_decode_cell_data(data, &field_type, &to_field_type, field_rev) {
+            let TypeCellData { cell_str, field_type } = type_cell_data;
+            match try_decode_cell_str(cell_str, &field_type, &to_field_type, field_rev) {
                 Ok(cell_bytes) => (field_type, cell_bytes),
                 Err(e) => {
                     tracing::error!("Decode cell data failed, {:?}", e);
@@ -120,7 +120,7 @@ pub fn decode_type_cell_data<T: TryInto<TypeCellData, Error = FlowyError> + Debu
 ///
 /// # Arguments
 ///
-/// * `cell_data`: the opaque cell data
+/// * `cell_str`: the opaque cell string
 /// * `from_field_type`: the original field type of the passed-in cell data. Check the `TypeCellData`
 /// that is used to save the origin field type of the cell data.
 /// * `to_field_type`: decode the passed-in cell data to this field type. It will use the to_field_type's
@@ -129,15 +129,15 @@ pub fn decode_type_cell_data<T: TryInto<TypeCellData, Error = FlowyError> + Debu
 ///
 /// returns: CellBytes
 ///
-pub fn try_decode_cell_data(
-    cell_data: String,
+pub fn try_decode_cell_str(
+    cell_str: String,
     from_field_type: &FieldType,
     to_field_type: &FieldType,
     field_rev: &FieldRevision,
 ) -> FlowyResult<CellProtobufBlob> {
     match FieldRevisionExt::new(field_rev).get_type_option_cell_data_handler(to_field_type) {
         None => Ok(CellProtobufBlob::default()),
-        Some(handler) => handler.handle_cell_data(cell_data, from_field_type, field_rev),
+        Some(handler) => handler.handle_cell_str(cell_str, from_field_type, field_rev),
     }
 }
 
@@ -153,7 +153,7 @@ pub fn stringify_cell_data(
 ) -> String {
     match FieldRevisionExt::new(field_rev).get_type_option_cell_data_handler(to_field_type) {
         None => "".to_string(),
-        Some(handler) => handler.stringify_cell_data(cell_data, from_field_type, field_rev),
+        Some(handler) => handler.stringify_cell_str(cell_data, from_field_type, field_rev),
     }
 }
 

frontend/rust-lib/flowy-grid/src/services/cell/type_cell_data.rs

@@ -16,28 +16,29 @@ use serde::{Deserialize, Serialize};
 ///
 #[derive(Debug, Serialize, Deserialize)]
 pub struct TypeCellData {
-    pub data: String,
+    #[serde(rename = "data")]
+    pub cell_str: String,
     pub field_type: FieldType,
 }
 
 impl TypeCellData {
     pub fn from_field_type(field_type: &FieldType) -> TypeCellData {
         Self {
-            data: "".to_string(),
+            cell_str: "".to_string(),
             field_type: field_type.clone(),
         }
     }
 
     pub fn from_json_str(s: &str) -> FlowyResult<Self> {
         let type_cell_data: TypeCellData = serde_json::from_str(s).map_err(|err| {
-            let msg = format!("Deserialize {} to any cell data failed.{}", s, err);
+            let msg = format!("Deserialize {} to type cell data failed.{}", s, err);
             FlowyError::internal().context(msg)
         })?;
         Ok(type_cell_data)
     }
 
     pub fn into_inner(self) -> String {
-        self.data
+        self.cell_str
     }
 }
 
@@ -54,21 +55,21 @@ where
     T: FromCellString,
 {
     fn from(any_call_data: TypeCellData) -> Self {
-        IntoCellData::from(any_call_data.data)
+        IntoCellData::from(any_call_data.cell_str)
     }
 }
 
 impl ToString for TypeCellData {
     fn to_string(&self) -> String {
-        self.data.clone()
+        self.cell_str.clone()
     }
 }
 
 impl std::convert::TryFrom<&CellRevision> for TypeCellData {
     type Error = FlowyError;
 
     fn try_from(value: &CellRevision) -> Result<Self, Self::Error> {
-        Self::from_json_str(&value.data)
+        Self::from_json_str(&value.type_cell_data)
     }
 }
 
@@ -83,7 +84,7 @@ impl std::convert::TryFrom<CellRevision> for TypeCellData {
 impl TypeCellData {
     pub fn new(content: String, field_type: FieldType) -> Self {
         TypeCellData {
-            data: content,
+            cell_str: content,
             field_type,
         }
     }

frontend/rust-lib/flowy-grid/src/services/field/type_options/checkbox_type_option/checkbox_filter.rs

@@ -22,7 +22,7 @@ impl CellFilterable for CheckboxTypeOptionPB {
         if !type_cell_data.is_checkbox() {
             return Ok(true);
         }
-        let checkbox_cell_data = self.decode_type_option_cell_data(type_cell_data.data)?;
+        let checkbox_cell_data = self.decode_type_option_cell_str(type_cell_data.cell_str)?;
         Ok(filter.is_visible(&checkbox_cell_data))
     }
 }

frontend/rust-lib/flowy-grid/src/services/field/type_options/checkbox_type_option/checkbox_tests.rs

@@ -36,7 +36,7 @@ mod tests {
     ) {
         assert_eq!(
             type_option
-                .decode_cell_data(input_str.to_owned(), field_type, field_rev)
+                .decode_cell_str(input_str.to_owned(), field_type, field_rev)
                 .unwrap()
                 .to_string(),
             expected_str.to_owned()

frontend/rust-lib/flowy-grid/src/services/field/type_options/checkbox_type_option/checkbox_type_option.rs

@@ -58,23 +58,23 @@ impl TypeOptionCellData for CheckboxTypeOptionPB {
         cell_data
     }
 
-    fn decode_type_option_cell_data(&self, cell_data: String) -> FlowyResult<<Self as TypeOption>::CellData> {
-        CheckboxCellData::from_cell_str(&cell_data)
+    fn decode_type_option_cell_str(&self, cell_str: String) -> FlowyResult<<Self as TypeOption>::CellData> {
+        CheckboxCellData::from_cell_str(&cell_str)
     }
 }
 
 impl CellDataDecoder for CheckboxTypeOptionPB {
-    fn decode_cell_data(
+    fn decode_cell_str(
         &self,
-        cell_data: String,
+        cell_str: String,
         decoded_field_type: &FieldType,
         _field_rev: &FieldRevision,
     ) -> FlowyResult<<Self as TypeOption>::CellData> {
         if !decoded_field_type.is_checkbox() {
             return Ok(Default::default());
         }
 
-        self.decode_type_option_cell_data(cell_data)
+        self.decode_type_option_cell_str(cell_str)
     }
 
     fn decode_cell_data_to_str(&self, cell_data: <Self as TypeOption>::CellData) -> String {

frontend/rust-lib/flowy-grid/src/services/field/type_options/date_type_option/date_filter.rs

@@ -70,7 +70,7 @@ impl CellFilterable for DateTypeOptionPB {
             return Ok(true);
         }
 
-        let date_cell_data = self.decode_type_option_cell_data(type_cell_data.data)?;
+        let date_cell_data = self.decode_type_option_cell_str(type_cell_data.cell_str)?;
         Ok(filter.is_visible(date_cell_data))
     }
 }

frontend/rust-lib/flowy-grid/src/services/field/type_options/date_type_option/date_tests.rs

@@ -162,7 +162,7 @@ mod tests {
 
     fn decode_cell_data(encoded_data: String, type_option: &DateTypeOptionPB, field_rev: &FieldRevision) -> String {
         let decoded_data = type_option
-            .decode_cell_data(encoded_data, &FieldType::DateTime, field_rev)
+            .decode_cell_str(encoded_data, &FieldType::DateTime, field_rev)
             .unwrap();
         let decoded_data = type_option.convert_to_protobuf(decoded_data);
         if type_option.include_time {