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

chore: unit test for cell content

Browse Source
This commit is contained in:
appflowy
2022-07-13 17:25:03 +08:00
parent f10e324b73
commit 602aab45e2
33 changed files with 338 additions and 175 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@ -1,5 +1,6 @@
use crate::grid::block_test::script::GridRowTest;
use crate::grid::block_test::script::RowScript::*;
use flowy_grid::entities::FieldType;
use flowy_grid_data_model::revision::RowMetaChangeset;
#[tokio::test]
@ -67,15 +68,48 @@ async fn grid_row_add_cells_test() {
let mut test = GridRowTest::new().await;
let mut builder = test.row_builder();
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());
let text_field_id = builder.insert_text_cell("hello world");
let number_field_id = builder.insert_number_cell("18,443");
let date_field_id = builder.insert_date_cell("1647251762");
let single_select_field_id = 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 url_field_id = builder.insert_url_cell("https://appflowy.io");
let row_rev = builder.build();
let scripts = vec![CreateRow { row_rev }];
let row_id = row_rev.id.clone();
let scripts = vec![
CreateRow { row_rev },
AssertCell {
row_id: row_id.clone(),
field_id: text_field_id,
field_type: FieldType::RichText,
expected: "hello world".to_owned(),
},
AssertCell {
row_id: row_id.clone(),
field_id: number_field_id,
field_type: FieldType::Number,
expected: "$18,443.00".to_owned(),
},
AssertCell {
row_id: row_id.clone(),
field_id: single_select_field_id,
field_type: FieldType::SingleSelect,
expected: "Completed".to_owned(),
},
AssertCell {
row_id: row_id.clone(),
field_id: date_field_id,
field_type: FieldType::DateTime,
expected: "2022/03/14".to_owned(),
},
AssertCell {
row_id: row_id.clone(),
field_id: url_field_id,
field_type: FieldType::URL,
expected: "https://appflowy.io/".to_owned(),
},
];
test.run_scripts(scripts).await;
}

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

@ -1,7 +1,11 @@
use crate::grid::block_test::util::GridRowTestBuilder;
use crate::grid::grid_editor::GridEditorTest;
use flowy_grid::entities::{CellIdentifier, RowInfo};
use flowy_grid::entities::{CellIdentifier, FieldType, RowInfo};
use flowy_grid::services::field::{
DateCellDataParser, NumberCellDataParser, NumberFormat, NumberTypeOption, SelectOptionCellDataParser,
SelectOptionIdsParser, SelectOptionOperation, SingleSelectTypeOption, TextCellDataParser, URLCellDataParser,
};
use flowy_grid_data_model::revision::{
GridBlockMetaRevision, GridBlockMetaRevisionChangeset, RowMetaChangeset, RowRevision,
};
@ -24,7 +28,8 @@ pub enum RowScript {
AssertCell {
row_id: String,
field_id: String,
expected_display: Option<String>,
field_type: FieldType,
expected: String,
},
AssertRowCount(usize),
CreateBlock {
@ -101,20 +106,15 @@ impl GridRowTest {
RowScript::AssertCell {
row_id,
field_id,
expected_display,
field_type,
expected,
} => {
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);
}
}
self.compare_cell_content(id, field_type, expected).await;
}
RowScript::AssertRow { expected_row } => {
let row = &*self
@ -153,6 +153,72 @@ impl GridRowTest {
}
}
}
async fn compare_cell_content(&self, cell_id: CellIdentifier, field_type: FieldType, expected: String) {
match field_type {
FieldType::RichText => {
let cell_data = self
.editor
.get_cell_bytes(&cell_id)
.await
.unwrap()
.with_parser(TextCellDataParser())
.unwrap();
assert_eq!(cell_data.as_ref(), &expected);
}
FieldType::Number => {
let field_rev = self.editor.get_field_rev(&cell_id.field_id).await.unwrap();
let number_type_option = field_rev
.get_type_option_entry::<NumberTypeOption>(FieldType::Number.into())
.unwrap();
let cell_data = self
.editor
.get_cell_bytes(&cell_id)
.await
.unwrap()
.with_parser(NumberCellDataParser(number_type_option.format.clone()))
.unwrap();
assert_eq!(cell_data.to_string(), expected);
}
FieldType::DateTime => {
let cell_data = self
.editor
.get_cell_bytes(&cell_id)
.await
.unwrap()
.with_parser(DateCellDataParser())
.unwrap();
assert_eq!(cell_data.date, expected);
}
FieldType::SingleSelect => {
let select_options = self
.editor
.get_cell_bytes(&cell_id)
.await
.unwrap()
.with_parser(SelectOptionCellDataParser())
.unwrap();
let select_option = select_options.select_options.first().unwrap();
assert_eq!(select_option.name, expected);
}
FieldType::MultiSelect => {}
FieldType::Checkbox => {}
FieldType::URL => {
let cell_data = self
.editor
.get_cell_bytes(&cell_id)
.await
.unwrap()
.with_parser(URLCellDataParser())
.unwrap();
assert_eq!(cell_data.content, expected);
assert_eq!(cell_data.url, expected);
}
}
}
}
impl std::ops::Deref for GridRowTest {

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

@ -23,21 +23,24 @@ impl<'a> GridRowTestBuilder<'a> {
}
}
pub fn insert_text_cell(&mut self, data: &str) {
pub fn insert_text_cell(&mut self, data: &str) -> String {
let text_field = self.field_rev_with_type(&FieldType::RichText);
self.inner_builder
.insert_cell(&text_field.id, data.to_string())
.unwrap();
text_field.id.clone()
}
pub fn insert_number_cell(&mut self, data: &str) {
pub fn insert_number_cell(&mut self, data: &str) -> String {
let number_field = self.field_rev_with_type(&FieldType::Number);
self.inner_builder
.insert_cell(&number_field.id, data.to_string())
.unwrap();
number_field.id.clone()
}
pub fn insert_date_cell(&mut self, data: &str) {
pub fn insert_date_cell(&mut self, data: &str) -> String {
let value = serde_json::to_string(&DateCellChangeset {
date: Some(data.to_string()),
time: None,
@ -45,6 +48,7 @@ impl<'a> GridRowTestBuilder<'a> {
.unwrap();
let date_field = self.field_rev_with_type(&FieldType::DateTime);
self.inner_builder.insert_cell(&date_field.id, value).unwrap();
date_field.id.clone()
}
pub fn insert_checkbox_cell(&mut self, data: &str) {
@ -54,14 +58,13 @@ impl<'a> GridRowTestBuilder<'a> {
.unwrap();
}
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_url_cell(&mut self, data: &str) -> String {
let url_field = self.field_rev_with_type(&FieldType::URL);
self.inner_builder.insert_cell(&url_field.id, data.to_string()).unwrap();
url_field.id.clone()
}
pub fn insert_single_select_cell<F>(&mut self, f: F)
pub fn insert_single_select_cell<F>(&mut self, f: F) -> String
where
F: Fn(&Vec<SelectOption>) -> &SelectOption,
{
@ -71,6 +74,8 @@ impl<'a> GridRowTestBuilder<'a> {
self.inner_builder
.insert_select_option_cell(&single_select_field.id, option.id.clone())
.unwrap();
single_select_field.id.clone()
}
pub fn insert_multi_select_cell<F>(&mut self, f: F)

10
frontend/rust-lib/flowy-grid/tests/grid/filter_test/text_filter_test.rs
View File

@ -1,12 +1,12 @@
use crate::grid::filter_test::script::FilterScript::*;
use crate::grid::filter_test::script::*;
use flowy_grid::entities::{CreateGridFilterPayload, TextFilterCondition};
use flowy_grid::entities::{CreateGridFilterPayload, FieldType, TextFilterCondition};
use flowy_grid_data_model::revision::FieldRevision;
#[tokio::test]
async fn grid_filter_create_test() {
let mut test = GridFilterTest::new().await;
let field_rev = test.text_field();
let field_rev = test.get_field_rev(FieldType::RichText);
let payload = CreateGridFilterPayload::new(field_rev, TextFilterCondition::TextIsEmpty, Some("abc".to_owned()));
let scripts = vec![InsertGridTableFilter { payload }, AssertTableFilterCount { count: 1 }];
test.run_scripts(scripts).await;
@ -16,7 +16,7 @@ async fn grid_filter_create_test() {
#[should_panic]
async fn grid_filter_invalid_condition_panic_test() {
let mut test = GridFilterTest::new().await;
let field_rev = test.text_field().clone();
let field_rev = test.get_field_rev(FieldType::RichText).clone();
// 100 is not a valid condition, so this test should be panic.
let payload = CreateGridFilterPayload::new(&field_rev, 100, Some("".to_owned()));
@ -27,7 +27,7 @@ async fn grid_filter_invalid_condition_panic_test() {
#[tokio::test]
async fn grid_filter_delete_test() {
let mut test = GridFilterTest::new().await;
let field_rev = test.text_field().clone();
let field_rev = test.get_field_rev(FieldType::RichText).clone();
let payload = create_filter(&field_rev, TextFilterCondition::TextIsEmpty, "abc");
let scripts = vec![InsertGridTableFilter { payload }, AssertTableFilterCount { count: 1 }];
test.run_scripts(scripts).await;
@ -36,7 +36,7 @@ async fn grid_filter_delete_test() {
test.run_scripts(vec![
DeleteGridTableFilter {
filter_id: filter.id,
field_rev,
field_rev: field_rev.as_ref().clone(),
},
AssertTableFilterCount { count: 0 },
])

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

@ -64,7 +64,7 @@ impl GridEditorTest {
}
}
pub(crate) async fn get_row_revs(&self) -> Vec<Arc<RowRevision>> {
pub async fn get_row_revs(&self) -> Vec<Arc<RowRevision>> {
self.editor
.grid_block_snapshots(None)
.await
@ -79,12 +79,12 @@ impl GridEditorTest {
self.editor.get_grid_filter(&layout_type).await.unwrap()
}
pub fn text_field(&self) -> &FieldRevision {
pub fn get_field_rev(&self, field_type: FieldType) -> &Arc<FieldRevision> {
self.field_revs
.iter()
.filter(|field_rev| {
let t_field_type: FieldType = field_rev.field_type_rev.into();
t_field_type == FieldType::RichText
t_field_type == field_type
})
.collect::<Vec<_>>()
.pop()
@ -129,7 +129,6 @@ fn make_test_grid() -> BuildGridContext {
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"));