Mirrored_Repos/AppFlowy
1
0
Fork 0
mirror of https://github.com/AppFlowy-IO/AppFlowy.git synced 2024-08-30 18:12:39 +00:00
Code Issues Packages Projects Releases Wiki Activity

refactor: row builder

Browse Source
This commit is contained in:
appflowy
2022-07-12 15:49:14 +08:00
parent 6020459f76
commit 284755eccf
11 changed files with 288 additions and 295 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@ -1,13 +1,5 @@
use crate::grid::block_test::script::GridRowTest;
use crate::grid::block_test::script::RowScript::*;
use crate::grid::block_test::util::GridRowTestBuilder;
use chrono::NaiveDateTime;
use flowy_grid::entities::FieldType;
use flowy_grid::services::cell::decode_any_cell_data;
use flowy_grid::services::field::select_option::SELECTION_IDS_SEPARATOR;
use flowy_grid::services::field::{DateCellData, MultiSelectTypeOption, SingleSelectTypeOption};
use crate::grid::field_test::util::make_date_cell_string;
use flowy_grid_data_model::revision::RowMetaChangeset;
#[tokio::test]
@ -18,7 +10,7 @@ async fn grid_create_row_count_test() {
CreateEmptyRow,
CreateEmptyRow,
CreateRow {
payload: GridRowTestBuilder::new(&test).build(),
row_rev: test.row_builder().build(),
},
AssertRowCount(6),
];
@ -28,15 +20,15 @@ async fn grid_create_row_count_test() {
#[tokio::test]
async fn grid_update_row() {
let mut test = GridRowTest::new().await;
let payload = GridRowTestBuilder::new(&test).build();
let row_rev = test.row_builder().build();
let changeset = RowMetaChangeset {
row_id: payload.row_id.clone(),
row_id: row_rev.id.clone(),
height: None,
visibility: None,
cell_by_field_id: Default::default(),
};
let scripts = vec![AssertRowCount(3), CreateRow { payload }, UpdateRow { changeset }];
let scripts = vec![AssertRowCount(3), CreateRow { row_rev }, UpdateRow { changeset }];
test.run_scripts(scripts).await;
let expected_row = test.last_row().unwrap();
@ -47,13 +39,13 @@ async fn grid_update_row() {
#[tokio::test]
async fn grid_delete_row() {
let mut test = GridRowTest::new().await;
let payload1 = GridRowTestBuilder::new(&test).build();
let payload2 = GridRowTestBuilder::new(&test).build();
let row_ids = vec![payload1.row_id.clone(), payload2.row_id.clone()];
let row_1 = test.row_builder().build();
let row_2 = test.row_builder().build();
let row_ids = vec![row_1.id.clone(), row_2.id.clone()];
let scripts = vec![
AssertRowCount(3),
CreateRow { payload: payload1 },
CreateRow { payload: payload2 },
CreateRow { row_rev: row_1 },
CreateRow { row_rev: row_2 },
AssertBlockCount(1),
AssertBlock {
block_index: 0,
@ -73,78 +65,17 @@ async fn grid_delete_row() {
#[tokio::test]
async fn grid_row_add_cells_test() {
let mut test = GridRowTest::new().await;
let mut builder = test.builder();
for field in test.field_revs() {
let field_type: FieldType = field.field_type_rev.into();
match field_type {
FieldType::RichText => {
builder.add_cell(&field.id, "hello world".to_owned()).unwrap();
}
FieldType::Number => {
builder.add_cell(&field.id, "18,443".to_owned()).unwrap();
}
FieldType::DateTime => {
builder
.add_cell(&field.id, make_date_cell_string("1647251762"))
.unwrap();
}
FieldType::SingleSelect => {
let type_option = SingleSelectTypeOption::from(field);
let option = type_option.options.first().unwrap();
builder.add_select_option_cell(&field.id, option.id.clone()).unwrap();
}
FieldType::MultiSelect => {
let type_option = MultiSelectTypeOption::from(field);
let ops_ids = type_option
.options
.iter()
.map(|option| option.id.clone())
.collect::<Vec<_>>()
.join(SELECTION_IDS_SEPARATOR);
builder.add_select_option_cell(&field.id, ops_ids).unwrap();
}
FieldType::Checkbox => {
builder.add_cell(&field.id, "false".to_string()).unwrap();
}
FieldType::URL => {
builder.add_cell(&field.id, "1".to_string()).unwrap();
}
}
}
let context = builder.build();
let scripts = vec![CreateRow { payload: context }];
test.run_scripts(scripts).await;
}
let mut builder = test.row_builder();
#[tokio::test]
async fn grid_row_add_date_cell_test() {
let mut test = GridRowTest::new().await;
let mut builder = test.builder();
let mut date_field = None;
let timestamp = 1647390674;
for field in test.field_revs() {
let field_type: FieldType = field.field_type_rev.into();
if field_type == FieldType::DateTime {
date_field = Some(field.clone());
NaiveDateTime::from_timestamp(123, 0);
// The data should not be empty
assert!(builder.add_cell(&field.id, "".to_string()).is_err());
assert!(builder.add_cell(&field.id, make_date_cell_string("123")).is_ok());
assert!(builder
.add_cell(&field.id, make_date_cell_string(&timestamp.to_string()))
.is_ok());
}
}
let context = builder.build();
let date_field = date_field.unwrap();
let cell_rev = context.cell_by_field_id.get(&date_field.id).unwrap();
assert_eq!(
decode_any_cell_data(cell_rev, &date_field)
.parse::<DateCellData>()
.unwrap()
.date,
"2022/03/16",
);
let scripts = vec![CreateRow { payload: context }];
builder.insert_text_cell("hello world");
builder.insert_number_cell("18,443");
builder.insert_date_cell("1647251762");
builder.insert_single_select_cell(|options| options.first().unwrap());
builder.insert_multi_select_cell(|options| options);
builder.insert_checkbox_cell("false");
builder.insert_url_cell("1");
let row_rev = builder.build();
let scripts = vec![CreateRow { row_rev }];
test.run_scripts(scripts).await;
}

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

@ -1,15 +1,16 @@
use crate::grid::block_test::util::GridRowTestBuilder;
use crate::grid::grid_editor::GridEditorTest;
use flowy_grid::entities::RowInfo;
use flowy_grid::services::row::{CreateRowRevisionBuilder, CreateRowRevisionPayload};
use flowy_grid::entities::{CellIdentifier, RowInfo};
use flowy_grid_data_model::revision::{
FieldRevision, GridBlockMetaRevision, GridBlockMetaRevisionChangeset, RowMetaChangeset, RowRevision,
GridBlockMetaRevision, GridBlockMetaRevisionChangeset, RowMetaChangeset, RowRevision,
};
use std::sync::Arc;
pub enum RowScript {
CreateEmptyRow,
CreateRow {
payload: CreateRowRevisionPayload,
row_rev: RowRevision,
},
UpdateRow {
changeset: RowMetaChangeset,
@ -20,6 +21,11 @@ pub enum RowScript {
DeleteRows {
row_ids: Vec<String>,
},
AssertCell {
row_id: String,
field_id: String,
expected_display: Option<String>,
},
AssertRowCount(usize),
CreateBlock {
block: GridBlockMetaRevision,
@ -49,10 +55,6 @@ impl GridRowTest {
Self { inner: editor_test }
}
pub fn field_revs(&self) -> &Vec<Arc<FieldRevision>> {
&self.field_revs
}
pub fn last_row(&self) -> Option<RowRevision> {
self.row_revs.last().map(|a| a.clone().as_ref().clone())
}
@ -63,8 +65,8 @@ impl GridRowTest {
}
}
pub fn builder(&self) -> CreateRowRevisionBuilder {
CreateRowRevisionBuilder::new(&self.field_revs)
pub fn row_builder(&self) -> GridRowTestBuilder {
GridRowTestBuilder::new(self.block_id(), &self.field_revs)
}
pub async fn run_script(&mut self, script: RowScript) {
@ -76,8 +78,8 @@ impl GridRowTest {
self.row_revs = self.get_row_revs().await;
self.block_meta_revs = self.editor.get_block_meta_revs().await.unwrap();
}
RowScript::CreateRow { payload: context } => {
let row_orders = self.editor.insert_rows(vec![context]).await.unwrap();
RowScript::CreateRow { row_rev } => {
let row_orders = self.editor.insert_rows(vec![row_rev]).await.unwrap();
for row_order in row_orders {
self.row_order_by_row_id
.insert(row_order.row_id().to_owned(), row_order);
@ -96,6 +98,24 @@ impl GridRowTest {
self.row_revs = self.get_row_revs().await;
self.block_meta_revs = self.editor.get_block_meta_revs().await.unwrap();
}
RowScript::AssertCell {
row_id,
field_id,
expected_display,
} => {
let id = CellIdentifier {
grid_id: self.grid_id.clone(),
field_id,
row_id,
};
let display = self.editor.get_cell_display(&id).await;
match expected_display {
None => {}
Some(expected_display) => {
assert_eq!(display.unwrap(), expected_display);
}
}
}
RowScript::AssertRow { expected_row } => {
let row = &*self
.row_revs

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

@ -1,66 +1,97 @@
use crate::grid::block_test::script::GridRowTest;
use flowy_grid::entities::FieldType;
use flowy_grid::services::field::DateCellChangeset;
use flowy_grid::services::row::{CreateRowRevisionBuilder, CreateRowRevisionPayload};
use flowy_grid_data_model::revision::FieldRevision;
use flowy_grid::services::field::select_option::{SelectOption, SELECTION_IDS_SEPARATOR};
use flowy_grid::services::field::{DateCellChangeset, MultiSelectTypeOption, SingleSelectTypeOption};
use flowy_grid::services::row::RowRevisionBuilder;
use flowy_grid_data_model::revision::{FieldRevision, RowRevision};
use std::sync::Arc;
use strum::EnumCount;
pub struct GridRowTestBuilder<'a> {
test: &'a GridRowTest,
inner_builder: CreateRowRevisionBuilder<'a>,
block_id: String,
field_revs: &'a [Arc<FieldRevision>],
inner_builder: RowRevisionBuilder<'a>,
}
impl<'a> GridRowTestBuilder<'a> {
pub fn new(test: &'a GridRowTest) -> Self {
assert_eq!(test.field_revs().len(), FieldType::COUNT);
let inner_builder = CreateRowRevisionBuilder::new(test.field_revs());
Self { test, inner_builder }
}
#[allow(dead_code)]
pub fn update_text_cell(mut self, data: String) -> Self {
let text_field = self.field_rev_with_type(&FieldType::DateTime);
self.inner_builder.add_cell(&text_field.id, data).unwrap();
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 {
block_id: block_id.to_owned(),
field_revs,
inner_builder,
}
}
#[allow(dead_code)]
pub fn update_number_cell(mut self, data: String) -> Self {
let number_field = self.field_rev_with_type(&FieldType::DateTime);
self.inner_builder.add_cell(&number_field.id, data).unwrap();
self
pub fn insert_text_cell(&mut self, data: &str) {
let text_field = self.field_rev_with_type(&FieldType::RichText);
self.inner_builder
.insert_cell(&text_field.id, data.to_string())
.unwrap();
}
#[allow(dead_code)]
pub fn update_date_cell(mut self, value: i64) -> Self {
pub fn insert_number_cell(&mut self, data: &str) {
let number_field = self.field_rev_with_type(&FieldType::Number);
self.inner_builder
.insert_cell(&number_field.id, data.to_string())
.unwrap();
}
pub fn insert_date_cell(&mut self, data: &str) {
let value = serde_json::to_string(&DateCellChangeset {
date: Some(value.to_string()),
date: Some(data.to_string()),
time: None,
})
.unwrap();
let date_field = self.field_rev_with_type(&FieldType::DateTime);
self.inner_builder.add_cell(&date_field.id, value).unwrap();
self
self.inner_builder.insert_cell(&date_field.id, value).unwrap();
}
#[allow(dead_code)]
pub fn update_checkbox_cell(mut self, data: bool) -> Self {
pub fn insert_checkbox_cell(&mut self, data: &str) {
let number_field = self.field_rev_with_type(&FieldType::Checkbox);
self.inner_builder.add_cell(&number_field.id, data.to_string()).unwrap();
self
self.inner_builder
.insert_cell(&number_field.id, data.to_string())
.unwrap();
}
#[allow(dead_code)]
pub fn update_url_cell(mut self, data: String) -> Self {
let number_field = self.field_rev_with_type(&FieldType::Checkbox);
self.inner_builder.add_cell(&number_field.id, data).unwrap();
self
pub fn insert_url_cell(&mut self, data: &str) {
let number_field = self.field_rev_with_type(&FieldType::URL);
self.inner_builder
.insert_cell(&number_field.id, data.to_string())
.unwrap();
}
pub fn insert_single_select_cell<F>(&mut self, f: F)
where
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);
self.inner_builder
.insert_select_option_cell(&single_select_field.id, option.id.clone())
.unwrap();
}
pub fn insert_multi_select_cell<F>(&mut self, f: F)
where
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 ops_ids = options
.iter()
.map(|option| option.id.clone())
.collect::<Vec<_>>()
.join(SELECTION_IDS_SEPARATOR);
self.inner_builder
.insert_select_option_cell(&multi_select_field.id, ops_ids)
.unwrap();
}
pub fn field_rev_with_type(&self, field_type: &FieldType) -> FieldRevision {
self.test
.field_revs()
self.field_revs
.iter()
.find(|field_rev| {
let t_field_type: FieldType = field_rev.field_type_rev.into();
@ -71,7 +102,7 @@ impl<'a> GridRowTestBuilder<'a> {
.clone()
}
pub fn build(self) -> CreateRowRevisionPayload {
self.inner_builder.build()
pub fn build(self) -> RowRevision {
self.inner_builder.build(&self.block_id)
}
}

163
frontend/rust-lib/flowy-grid/tests/grid/grid_editor.rs
View File

@ -6,7 +6,7 @@ use flowy_grid::entities::*;
use flowy_grid::services::field::select_option::SelectOption;
use flowy_grid::services::field::*;
use flowy_grid::services::grid_editor::{GridPadBuilder, GridRevisionEditor};
use flowy_grid::services::row::CreateRowRevisionPayload;
use flowy_grid::services::row::{CreateRowRevisionPayload, RowRevisionBuilder};
use flowy_grid::services::setting::GridSettingChangesetBuilder;
use flowy_grid_data_model::revision::*;
use flowy_revision::REVISION_WRITE_INTERVAL_IN_MILLIS;
@ -20,6 +20,7 @@ use std::collections::HashMap;
use std::sync::Arc;
use std::time::Duration;
use strum::EnumCount;
use strum::IntoEnumIterator;
use tokio::time::sleep;
pub struct GridEditorTest {
@ -37,14 +38,13 @@ impl GridEditorTest {
pub async fn new() -> Self {
let sdk = FlowySDKTest::default();
let _ = sdk.init_user().await;
let build_context = make_all_field_test_grid();
let build_context = make_test_grid();
let view_data: Bytes = build_context.into();
let test = ViewTest::new_grid_view(&sdk, view_data.to_vec()).await;
let editor = sdk.grid_manager.open_grid(&test.view.id).await.unwrap();
let field_revs = editor.get_field_revs(None).await.unwrap();
let block_meta_revs = editor.get_block_meta_revs().await.unwrap();
let row_revs = editor.grid_block_snapshots(None).await.unwrap().pop().unwrap().row_revs;
assert_eq!(row_revs.len(), 3);
assert_eq!(block_meta_revs.len(), 1);
// It seems like you should add the field in the make_test_grid() function.
@ -90,75 +90,98 @@ impl GridEditorTest {
.pop()
.unwrap()
}
pub fn block_id(&self) -> &str {
&self.block_meta_revs.last().unwrap().block_id
}
}
fn make_all_field_test_grid() -> BuildGridContext {
let text_field = FieldBuilder::new(RichTextTypeOptionBuilder::default())
.name("Name")
.visibility(true)
.build();
// This grid is assumed to contain all the Fields.
fn make_test_grid() -> BuildGridContext {
let mut grid_builder = GridBuilder::new();
// Iterate through the FieldType to create the corresponding Field.
for field_type in FieldType::iter() {
let field_type: FieldType = field_type;
// Single Select
let single_select = SingleSelectTypeOptionBuilder::default()
.option(SelectOption::new("Live"))
.option(SelectOption::new("Completed"))
.option(SelectOption::new("Planned"))
.option(SelectOption::new("Paused"));
let single_select_field = FieldBuilder::new(single_select).name("Status").visibility(true).build();
// The
match field_type {
FieldType::RichText => {
let text_field = FieldBuilder::new(RichTextTypeOptionBuilder::default())
.name("Name")
.visibility(true)
.build();
grid_builder.add_field(text_field);
}
FieldType::Number => {
// Number
let number = NumberTypeOptionBuilder::default().set_format(NumberFormat::USD);
let number_field = FieldBuilder::new(number).name("Price").visibility(true).build();
grid_builder.add_field(number_field);
}
FieldType::DateTime => {
// Date
let date = DateTypeOptionBuilder::default()
.date_format(DateFormat::US)
.time_format(TimeFormat::TwentyFourHour);
let date_field = FieldBuilder::new(date).name("Time").visibility(true).build();
grid_builder.add_field(date_field);
}
FieldType::SingleSelect => {
// Single Select
let single_select = SingleSelectTypeOptionBuilder::default()
.option(SelectOption::new("Live"))
.option(SelectOption::new("Completed"))
.option(SelectOption::new("Planned"))
.option(SelectOption::new("Paused"));
let single_select_field = FieldBuilder::new(single_select).name("Status").visibility(true).build();
grid_builder.add_field(single_select_field);
}
FieldType::MultiSelect => {
// MultiSelect
let multi_select = MultiSelectTypeOptionBuilder::default()
.option(SelectOption::new("Google"))
.option(SelectOption::new("Facebook"))
.option(SelectOption::new("Twitter"));
let multi_select_field = FieldBuilder::new(multi_select)
.name("Platform")
.visibility(true)
.build();
grid_builder.add_field(multi_select_field);
}
FieldType::Checkbox => {
// Checkbox
let checkbox = CheckboxTypeOptionBuilder::default();
let checkbox_field = FieldBuilder::new(checkbox).name("is done").visibility(true).build();
grid_builder.add_field(checkbox_field);
}
FieldType::URL => {
// URL
let url = URLTypeOptionBuilder::default();
let url_field = FieldBuilder::new(url).name("link").visibility(true).build();
grid_builder.add_field(url_field);
}
}
}
// MultiSelect
let multi_select = MultiSelectTypeOptionBuilder::default()
.option(SelectOption::new("Google"))
.option(SelectOption::new("Facebook"))
.option(SelectOption::new("Twitter"));
let multi_select_field = FieldBuilder::new(multi_select)
.name("Platform")
.visibility(true)
.build();
// Number
let number = NumberTypeOptionBuilder::default().set_format(NumberFormat::USD);
let number_field = FieldBuilder::new(number).name("Price").visibility(true).build();
// Date
let date = DateTypeOptionBuilder::default()
.date_format(DateFormat::US)
.time_format(TimeFormat::TwentyFourHour);
let date_field = FieldBuilder::new(date).name("Time").visibility(true).build();
// Checkbox
let checkbox = CheckboxTypeOptionBuilder::default();
let checkbox_field = FieldBuilder::new(checkbox).name("is done").visibility(true).build();
// URL
let url = URLTypeOptionBuilder::default();
let url_field = FieldBuilder::new(url).name("link").visibility(true).build();
// for i in 0..3 {
// for field_type in FieldType::iter() {
// let field_type: FieldType = field_type;
// match field_type {
// FieldType::RichText => {}
// FieldType::Number => {}
// FieldType::DateTime => {}
// FieldType::SingleSelect => {}
// FieldType::MultiSelect => {}
// FieldType::Checkbox => {}
// FieldType::URL => {}
// }
// }
// }
GridBuilder::default()
.add_field(text_field)
.add_field(single_select_field)
.add_field(multi_select_field)
.add_field(number_field)
.add_field(date_field)
.add_field(checkbox_field)
.add_field(url_field)
.add_empty_row()
.add_empty_row()
.add_empty_row()
.build()
// 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 => {}
}
}
}
// assert_eq!(row_revs.len(), 10);
// .add_empty_row()
// .add_empty_row()
// .add_empty_row()
grid_builder.build()
}