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

Merge branch 'main' into feat/history

Browse Source
This commit is contained in:
appflowy
2022-07-20 14:07:54 +08:00
parent d5eabe4ea3 471ae9ddf7
commit 1e3c69f15b
820 changed files with 15966 additions and 60868 deletions
Download Patch File Download Diff File Expand all files Collapse all files

41
frontend/rust-lib/flowy-grid/tests/grid/block_test/block_test.rs Normal file
View File

@ -0,0 +1,41 @@
use crate::grid::block_test::script::GridRowTest;
use crate::grid::block_test::script::RowScript::*;
use flowy_grid_data_model::revision::{GridBlockMetaRevision, GridBlockMetaRevisionChangeset};
#[tokio::test]
async fn grid_create_block() {
let block_meta_rev = GridBlockMetaRevision::new();
let scripts = vec![
AssertBlockCount(1),
CreateBlock { block: block_meta_rev },
AssertBlockCount(2),
];
GridRowTest::new().await.run_scripts(scripts).await;
}
#[tokio::test]
async fn grid_update_block() {
let block_meta_rev = GridBlockMetaRevision::new();
let mut cloned_grid_block = block_meta_rev.clone();
let changeset = GridBlockMetaRevisionChangeset {
block_id: block_meta_rev.block_id.clone(),
start_row_index: Some(2),
row_count: Some(10),
};
cloned_grid_block.start_row_index = 2;
cloned_grid_block.row_count = 10;
let scripts = vec![
AssertBlockCount(1),
CreateBlock { block: block_meta_rev },
UpdateBlock { changeset },
AssertBlockCount(2),
AssertBlockEqual {
block_index: 1,
block: cloned_grid_block,
},
];
GridRowTest::new().await.run_scripts(scripts).await;
}

5
frontend/rust-lib/flowy-grid/tests/grid/block_test/mod.rs Normal file
View File

@ -0,0 +1,5 @@
#![allow(clippy::module_inception)]
mod block_test;
mod row_test;
mod script;
pub mod util;

135
frontend/rust-lib/flowy-grid/tests/grid/block_test/row_test.rs Normal file
View File

@ -0,0 +1,135 @@
use crate::grid::block_test::script::RowScript::*;
use crate::grid::block_test::script::{CreateRowScriptBuilder, GridRowTest};
use crate::grid::grid_editor::{COMPLETED, FACEBOOK, GOOGLE, PAUSED, TWITTER};
use flowy_grid::entities::FieldType;
use flowy_grid::services::field::{NO, SELECTION_IDS_SEPARATOR};
use flowy_grid_data_model::revision::RowMetaChangeset;
#[tokio::test]
async fn grid_create_row_count_test() {
let mut test = GridRowTest::new().await;
let scripts = vec![
AssertRowCount(5),
CreateEmptyRow,
CreateEmptyRow,
CreateRow {
row_rev: test.row_builder().build(),
},
AssertRowCount(8),
];
test.run_scripts(scripts).await;
}
#[tokio::test]
async fn grid_update_row() {
let mut test = GridRowTest::new().await;
let row_rev = test.row_builder().build();
let changeset = RowMetaChangeset {
row_id: row_rev.id.clone(),
height: None,
visibility: None,
cell_by_field_id: Default::default(),
};
let scripts = vec![AssertRowCount(5), CreateRow { row_rev }, UpdateRow { changeset }];
test.run_scripts(scripts).await;
let expected_row = test.last_row().unwrap();
let scripts = vec![AssertRow { expected_row }, AssertRowCount(6)];
test.run_scripts(scripts).await;
}
#[tokio::test]
async fn grid_delete_row() {
let mut test = GridRowTest::new().await;
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(5),
CreateRow { row_rev: row_1 },
CreateRow { row_rev: row_2 },
AssertBlockCount(1),
AssertBlock {
block_index: 0,
row_count: 7,
start_row_index: 0,
},
DeleteRows { row_ids },
AssertBlock {
block_index: 0,
row_count: 5,
start_row_index: 0,
},
];
test.run_scripts(scripts).await;
}
#[tokio::test]
async fn grid_row_add_cells_test() {
let mut test = GridRowTest::new().await;
let mut builder = CreateRowScriptBuilder::new(&test);
builder.insert(FieldType::RichText, "hello world", "hello world");
builder.insert(FieldType::DateTime, "1647251762", "2022/03/14");
builder.insert(FieldType::Number, "18,443", "$18,443.00");
builder.insert(FieldType::Checkbox, "false", NO);
builder.insert(FieldType::URL, "https://appflowy.io", "https://appflowy.io");
builder.insert_single_select_cell(|mut options| options.remove(0), COMPLETED);
builder.insert_multi_select_cell(
|options| options,
&vec![GOOGLE, FACEBOOK, TWITTER].join(SELECTION_IDS_SEPARATOR),
);
let scripts = builder.build();
test.run_scripts(scripts).await;
}
#[tokio::test]
async fn grid_row_insert_number_test() {
let mut test = GridRowTest::new().await;
for (val, expected) in &[("1647251762", "2022/03/14"), ("2022/03/14", ""), ("", "")] {
let mut builder = CreateRowScriptBuilder::new(&test);
builder.insert(FieldType::DateTime, val, expected);
let scripts = builder.build();
test.run_scripts(scripts).await;
}
}
#[tokio::test]
async fn grid_row_insert_date_test() {
let mut test = GridRowTest::new().await;
for (val, expected) in &[
("18,443", "$18,443.00"),
("0", "$0.00"),
("100000", "$100,000.00"),
("$100,000.00", "$100,000.00"),
("", ""),
] {
let mut builder = CreateRowScriptBuilder::new(&test);
builder.insert(FieldType::Number, val, expected);
let scripts = builder.build();
test.run_scripts(scripts).await;
}
}
#[tokio::test]
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);
let scripts = builder.build();
test.run_scripts(scripts).await;
}
#[tokio::test]
async fn grid_row_insert_multi_select_test() {
let mut test = GridRowTest::new().await;
let mut builder = CreateRowScriptBuilder::new(&test);
builder.insert_multi_select_cell(
|mut options| {
options.remove(0);
options
},
&vec![FACEBOOK, TWITTER].join(SELECTION_IDS_SEPARATOR),
);
let scripts = builder.build();
test.run_scripts(scripts).await;
}

373
frontend/rust-lib/flowy-grid/tests/grid/block_test/script.rs Normal file
View File

@ -0,0 +1,373 @@
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::{CellIdentifierParams, FieldType, GridRowPB};
use flowy_grid::services::field::*;
use flowy_grid_data_model::revision::{
GridBlockMetaRevision, GridBlockMetaRevisionChangeset, RowMetaChangeset, RowRevision,
};
use std::collections::HashMap;
use std::sync::Arc;
use strum::IntoEnumIterator;
pub enum RowScript {
CreateEmptyRow,
CreateRow {
row_rev: RowRevision,
},
UpdateRow {
changeset: RowMetaChangeset,
},
AssertRow {
expected_row: RowRevision,
},
DeleteRows {
row_ids: Vec<String>,
},
AssertCell {
row_id: String,
field_id: String,
field_type: FieldType,
expected: String,
},
AssertRowCount(usize),
CreateBlock {
block: GridBlockMetaRevision,
},
UpdateBlock {
changeset: GridBlockMetaRevisionChangeset,
},
AssertBlockCount(usize),
AssertBlock {
block_index: usize,
row_count: i32,
start_row_index: i32,
},
AssertBlockEqual {
block_index: usize,
block: GridBlockMetaRevision,
},
}
pub struct GridRowTest {
inner: GridEditorTest,
}
impl GridRowTest {
pub async fn new() -> Self {
let editor_test = GridEditorTest::new().await;
Self { inner: editor_test }
}
pub fn last_row(&self) -> Option<RowRevision> {
self.row_revs.last().map(|a| a.clone().as_ref().clone())
}
pub async fn run_scripts(&mut self, scripts: Vec<RowScript>) {
for script in scripts {
self.run_script(script).await;
}
}
pub fn row_builder(&self) -> GridRowTestBuilder {
GridRowTestBuilder::new(self.block_id(), &self.field_revs)
}
pub async fn run_script(&mut self, script: RowScript) {
match script {
RowScript::CreateEmptyRow => {
let row_order = self.editor.create_row(None).await.unwrap();
self.row_order_by_row_id
.insert(row_order.row_id().to_owned(), row_order);
self.row_revs = self.get_row_revs().await;
self.block_meta_revs = self.editor.get_block_meta_revs().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);
}
self.row_revs = self.get_row_revs().await;
self.block_meta_revs = self.editor.get_block_meta_revs().await.unwrap();
}
RowScript::UpdateRow { changeset: change } => self.editor.update_row(change).await.unwrap(),
RowScript::DeleteRows { row_ids } => {
let row_orders = row_ids
.into_iter()
.map(|row_id| self.row_order_by_row_id.get(&row_id).unwrap().clone())
.collect::<Vec<GridRowPB>>();
self.editor.delete_rows(row_orders).await.unwrap();
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,
field_type,
expected,
} => {
let id = CellIdentifierParams {
grid_id: self.grid_id.clone(),
field_id,
row_id,
};
self.compare_cell_content(id, field_type, expected).await;
}
RowScript::AssertRow { expected_row } => {
let row = &*self
.row_revs
.iter()
.find(|row| row.id == expected_row.id)
.cloned()
.unwrap();
assert_eq!(&expected_row, row);
}
RowScript::AssertRowCount(expected_row_count) => {
assert_eq!(expected_row_count, self.row_revs.len());
}
RowScript::CreateBlock { block } => {
self.editor.create_block(block).await.unwrap();
self.block_meta_revs = self.editor.get_block_meta_revs().await.unwrap();
}
RowScript::UpdateBlock { changeset: change } => {
self.editor.update_block(change).await.unwrap();
}
RowScript::AssertBlockCount(count) => {
assert_eq!(self.editor.get_block_meta_revs().await.unwrap().len(), count);
}
RowScript::AssertBlock {
block_index,
row_count,
start_row_index,
} => {
assert_eq!(self.block_meta_revs[block_index].row_count, row_count);
assert_eq!(self.block_meta_revs[block_index].start_row_index, start_row_index);
}
RowScript::AssertBlockEqual { block_index, block } => {
let blocks = self.editor.get_block_meta_revs().await.unwrap();
let compared_block = blocks[block_index].clone();
assert_eq!(compared_block, Arc::new(block));
}
}
}
async fn compare_cell_content(&self, cell_id: CellIdentifierParams, 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))
.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 cell_data = self
.editor
.get_cell_bytes(&cell_id)
.await
.unwrap()
.with_parser(SelectOptionCellDataParser())
.unwrap();
let select_option = cell_data.select_options.first().unwrap();
assert_eq!(select_option.name, expected);
}
FieldType::MultiSelect => {
let cell_data = self
.editor
.get_cell_bytes(&cell_id)
.await
.unwrap()
.with_parser(SelectOptionCellDataParser())
.unwrap();
let s = cell_data
.select_options
.into_iter()
.map(|option| option.name)
.collect::<Vec<String>>()
.join(SELECTION_IDS_SEPARATOR);
assert_eq!(s, expected);
}
FieldType::Checkbox => {
let cell_data = self
.editor
.get_cell_bytes(&cell_id)
.await
.unwrap()
.with_parser(CheckboxCellDataParser())
.unwrap();
assert_eq!(cell_data.to_string(), expected);
}
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 {
type Target = GridEditorTest;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl std::ops::DerefMut for GridRowTest {
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.inner
}
}
pub struct CreateRowScriptBuilder<'a> {
builder: GridRowTestBuilder<'a>,
data_by_field_type: HashMap<FieldType, CellTestData>,
output_by_field_type: HashMap<FieldType, CellTestOutput>,
}
impl<'a> CreateRowScriptBuilder<'a> {
pub fn new(test: &'a GridRowTest) -> Self {
Self {
builder: test.row_builder(),
data_by_field_type: HashMap::new(),
output_by_field_type: HashMap::new(),
}
}
pub fn insert(&mut self, field_type: FieldType, input: &str, expected: &str) {
self.data_by_field_type.insert(
field_type,
CellTestData {
input: input.to_string(),
expected: expected.to_owned(),
},
);
}
pub fn insert_single_select_cell<F>(&mut self, f: F, expected: &str)
where
F: Fn(Vec<SelectOptionPB>) -> SelectOptionPB,
{
let field_id = self.builder.insert_single_select_cell(f);
self.output_by_field_type.insert(
FieldType::SingleSelect,
CellTestOutput {
field_id,
expected: expected.to_owned(),
},
);
}
pub fn insert_multi_select_cell<F>(&mut self, f: F, expected: &str)
where
F: Fn(Vec<SelectOptionPB>) -> Vec<SelectOptionPB>,
{
let field_id = self.builder.insert_multi_select_cell(f);
self.output_by_field_type.insert(
FieldType::MultiSelect,
CellTestOutput {
field_id,
expected: expected.to_owned(),
},
);
}
pub fn build(mut self) -> Vec<RowScript> {
let mut scripts = vec![];
let output_by_field_type = &mut self.output_by_field_type;
for field_type in FieldType::iter() {
let field_type: FieldType = field_type;
if let Some(data) = self.data_by_field_type.get(&field_type) {
let field_id = match field_type {
FieldType::RichText => self.builder.insert_text_cell(&data.input),
FieldType::Number => self.builder.insert_number_cell(&data.input),
FieldType::DateTime => self.builder.insert_date_cell(&data.input),
FieldType::Checkbox => self.builder.insert_checkbox_cell(&data.input),
FieldType::URL => self.builder.insert_url_cell(&data.input),
_ => "".to_owned(),
};
if !field_id.is_empty() {
output_by_field_type.insert(
field_type,
CellTestOutput {
field_id,
expected: data.expected.clone(),
},
);
}
}
}
let row_rev = self.builder.build();
let row_id = row_rev.id.clone();
scripts.push(CreateRow { row_rev });
for field_type in FieldType::iter() {
if let Some(data) = output_by_field_type.get(&field_type) {
let script = AssertCell {
row_id: row_id.clone(),
field_id: data.field_id.clone(),
field_type,
expected: data.expected.clone(),
};
scripts.push(script);
}
}
scripts
}
}
pub struct CellTestData {
pub input: String,
pub expected: String,
}
struct CellTestOutput {
field_id: String,
expected: String,
}

134
frontend/rust-lib/flowy-grid/tests/grid/block_test/util.rs Normal file
View File

@ -0,0 +1,134 @@
use flowy_grid::entities::FieldType;
use std::sync::Arc;
use flowy_grid::services::field::{
DateCellChangesetPB, MultiSelectTypeOption, SelectOptionPB, SingleSelectTypeOptionPB, SELECTION_IDS_SEPARATOR,
};
use flowy_grid::services::row::RowRevisionBuilder;
use flowy_grid_data_model::revision::{FieldRevision, RowRevision};
use strum::EnumCount;
pub struct GridRowTestBuilder<'a> {
block_id: String,
field_revs: &'a [Arc<FieldRevision>],
inner_builder: RowRevisionBuilder<'a>,
}
impl<'a> GridRowTestBuilder<'a> {
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,
}
}
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) -> 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) -> String {
let value = serde_json::to_string(&DateCellChangesetPB {
date: Some(data.to_string()),
time: None,
})
.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) -> String {
let checkbox_field = self.field_rev_with_type(&FieldType::Checkbox);
self.inner_builder
.insert_cell(&checkbox_field.id, data.to_string())
.unwrap();
checkbox_field.id.clone()
}
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) -> String
where
F: Fn(Vec<SelectOptionPB>) -> SelectOptionPB,
{
let single_select_field = self.field_rev_with_type(&FieldType::SingleSelect);
let type_option = SingleSelectTypeOptionPB::from(&single_select_field);
let option = f(type_option.options);
self.inner_builder
.insert_select_option_cell(&single_select_field.id, option.id)
.unwrap();
single_select_field.id.clone()
}
pub fn insert_multi_select_cell<F>(&mut self, f: F) -> String
where
F: Fn(Vec<SelectOptionPB>) -> Vec<SelectOptionPB>,
{
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();
multi_select_field.id.clone()
}
pub fn field_rev_with_type(&self, field_type: &FieldType) -> FieldRevision {
self.field_revs
.iter()
.find(|field_rev| {
let t_field_type: FieldType = field_rev.field_type_rev.into();
&t_field_type == field_type
})
.unwrap()
.as_ref()
.clone()
}
pub fn build(self) -> RowRevision {
self.inner_builder.build(&self.block_id)
}
}
impl<'a> std::ops::Deref for GridRowTestBuilder<'a> {
type Target = RowRevisionBuilder<'a>;
fn deref(&self) -> &Self::Target {
&self.inner_builder
}
}
impl<'a> std::ops::DerefMut for GridRowTestBuilder<'a> {
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.inner_builder
}
}

2
frontend/rust-lib/flowy-grid/tests/grid/cell_test/mod.rs Normal file
View File

@ -0,0 +1,2 @@
mod script;
mod test;

61
frontend/rust-lib/flowy-grid/tests/grid/cell_test/script.rs Normal file
View File

@ -0,0 +1,61 @@
use crate::grid::grid_editor::GridEditorTest;
use flowy_grid::entities::CellChangesetPB;
pub enum CellScript {
UpdateCell { changeset: CellChangesetPB, is_err: bool },
}
pub struct GridCellTest {
inner: GridEditorTest,
}
impl GridCellTest {
pub async fn new() -> Self {
let inner = GridEditorTest::new().await;
Self { inner }
}
pub async fn run_scripts(&mut self, scripts: Vec<CellScript>) {
for script in scripts {
self.run_script(script).await;
}
}
pub async fn run_script(&mut self, script: CellScript) {
// let grid_manager = self.sdk.grid_manager.clone();
// let pool = self.sdk.user_session.db_pool().unwrap();
let rev_manager = self.editor.rev_manager();
let _cache = rev_manager.revision_cache().await;
match script {
CellScript::UpdateCell { changeset, is_err } => {
let result = self.editor.update_cell(changeset).await;
if is_err {
assert!(result.is_err())
} else {
let _ = result.unwrap();
self.row_revs = self.get_row_revs().await;
}
} // CellScript::AssertGridRevisionPad => {
// sleep(Duration::from_millis(2 * REVISION_WRITE_INTERVAL_IN_MILLIS)).await;
// let mut grid_rev_manager = grid_manager.make_grid_rev_manager(&self.grid_id, pool.clone()).unwrap();
// let grid_pad = grid_rev_manager.load::<GridPadBuilder>(None).await.unwrap();
// println!("{}", grid_pad.delta_str());
// }
}
}
}
impl std::ops::Deref for GridCellTest {
type Target = GridEditorTest;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl std::ops::DerefMut for GridCellTest {
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.inner
}
}

51
frontend/rust-lib/flowy-grid/tests/grid/cell_test/test.rs Normal file
View File

@ -0,0 +1,51 @@
use crate::grid::cell_test::script::CellScript::*;
use crate::grid::cell_test::script::GridCellTest;
use crate::grid::field_test::util::make_date_cell_string;
use flowy_grid::entities::{CellChangesetPB, FieldType};
use flowy_grid::services::field::selection_type_option::SelectOptionCellChangeset;
use flowy_grid::services::field::{MultiSelectTypeOption, SingleSelectTypeOptionPB};
#[tokio::test]
async fn grid_cell_update() {
let mut test = GridCellTest::new().await;
let field_revs = &test.field_revs;
let row_revs = &test.row_revs;
let grid_blocks = &test.block_meta_revs;
// For the moment, We only have one block to store rows
let block_id = &grid_blocks.first().unwrap().block_id;
let mut scripts = vec![];
for (_, row_rev) in row_revs.iter().enumerate() {
for field_rev in field_revs {
let field_type: FieldType = field_rev.field_type_rev.into();
let data = match field_type {
FieldType::RichText => "".to_string(),
FieldType::Number => "123".to_string(),
FieldType::DateTime => make_date_cell_string("123"),
FieldType::SingleSelect => {
let type_option = SingleSelectTypeOptionPB::from(field_rev);
SelectOptionCellChangeset::from_insert(&type_option.options.first().unwrap().id).to_str()
}
FieldType::MultiSelect => {
let type_option = MultiSelectTypeOption::from(field_rev);
SelectOptionCellChangeset::from_insert(&type_option.options.first().unwrap().id).to_str()
}
FieldType::Checkbox => "1".to_string(),
FieldType::URL => "1".to_string(),
};
scripts.push(UpdateCell {
changeset: CellChangesetPB {
grid_id: block_id.to_string(),
row_id: row_rev.id.clone(),
field_id: field_rev.id.clone(),
content: Some(data),
},
is_err: false,
});
}
}
test.run_scripts(scripts).await;
}

3
frontend/rust-lib/flowy-grid/tests/grid/field_test/mod.rs Normal file
View File

@ -0,0 +1,3 @@
mod script;
mod test;
pub mod util;

94
frontend/rust-lib/flowy-grid/tests/grid/field_test/script.rs Normal file
View File

@ -0,0 +1,94 @@
use crate::grid::grid_editor::GridEditorTest;
use flowy_grid::entities::InsertFieldParams;
use flowy_grid_data_model::revision::FieldRevision;
use flowy_sync::entities::grid::FieldChangesetParams;
pub enum FieldScript {
CreateField {
params: InsertFieldParams,
},
UpdateField {
changeset: FieldChangesetParams,
},
DeleteField {
field_rev: FieldRevision,
},
AssertFieldCount(usize),
AssertFieldEqual {
field_index: usize,
field_rev: FieldRevision,
},
}
pub struct GridFieldTest {
inner: GridEditorTest,
}
impl GridFieldTest {
pub async fn new() -> Self {
let editor_test = GridEditorTest::new().await;
Self { inner: editor_test }
}
pub fn grid_id(&self) -> String {
self.grid_id.clone()
}
pub fn field_count(&self) -> usize {
self.field_count
}
pub async fn run_scripts(&mut self, scripts: Vec<FieldScript>) {
for script in scripts {
self.run_script(script).await;
}
}
pub async fn run_script(&mut self, script: FieldScript) {
match script {
FieldScript::CreateField { params } => {
if !self.editor.contain_field(&params.field.id).await {
self.field_count += 1;
}
self.editor.insert_field(params).await.unwrap();
self.field_revs = self.editor.get_field_revs(None).await.unwrap();
assert_eq!(self.field_count, self.field_revs.len());
}
FieldScript::UpdateField { changeset: change } => {
self.editor.update_field(change).await.unwrap();
self.field_revs = self.editor.get_field_revs(None).await.unwrap();
}
FieldScript::DeleteField { field_rev } => {
if self.editor.contain_field(&field_rev.id).await {
self.field_count -= 1;
}
self.editor.delete_field(&field_rev.id).await.unwrap();
self.field_revs = self.editor.get_field_revs(None).await.unwrap();
assert_eq!(self.field_count, self.field_revs.len());
}
FieldScript::AssertFieldCount(count) => {
assert_eq!(self.editor.get_field_revs(None).await.unwrap().len(), count);
}
FieldScript::AssertFieldEqual { field_index, field_rev } => {
let field_revs = self.editor.get_field_revs(None).await.unwrap();
assert_eq!(field_revs[field_index].as_ref(), &field_rev);
}
}
}
}
impl std::ops::Deref for GridFieldTest {
type Target = GridEditorTest;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl std::ops::DerefMut for GridFieldTest {
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.inner
}
}

115
frontend/rust-lib/flowy-grid/tests/grid/field_test/test.rs Normal file
View File

@ -0,0 +1,115 @@
use crate::grid::field_test::script::FieldScript::*;
use crate::grid::field_test::script::GridFieldTest;
use crate::grid::field_test::util::*;
use flowy_grid::services::field::selection_type_option::SelectOptionPB;
use flowy_grid::services::field::SingleSelectTypeOptionPB;
use flowy_grid_data_model::revision::TypeOptionDataEntry;
use flowy_sync::entities::grid::FieldChangesetParams;
#[tokio::test]
async fn grid_create_field() {
let mut test = GridFieldTest::new().await;
let (params, field_rev) = create_text_field(&test.grid_id());
let scripts = vec![
CreateField { params },
AssertFieldEqual {
field_index: test.field_count(),
field_rev,
},
];
test.run_scripts(scripts).await;
let (params, field_rev) = create_single_select_field(&test.grid_id());
let scripts = vec![
CreateField { params },
AssertFieldEqual {
field_index: test.field_count(),
field_rev,
},
];
test.run_scripts(scripts).await;
}
#[tokio::test]
async fn grid_create_duplicate_field() {
let mut test = GridFieldTest::new().await;
let (params, _) = create_text_field(&test.grid_id());
let field_count = test.field_count();
let expected_field_count = field_count + 1;
let scripts = vec![
CreateField { params: params.clone() },
CreateField { params },
AssertFieldCount(expected_field_count),
];
test.run_scripts(scripts).await;
}
#[tokio::test]
async fn grid_update_field_with_empty_change() {
let mut test = GridFieldTest::new().await;
let (params, field_rev) = create_single_select_field(&test.grid_id());
let changeset = FieldChangesetParams {
field_id: field_rev.id.clone(),
grid_id: test.grid_id(),
..Default::default()
};
let scripts = vec![
CreateField { params },
UpdateField { changeset },
AssertFieldEqual {
field_index: test.field_count(),
field_rev,
},
];
test.run_scripts(scripts).await;
}
#[tokio::test]
async fn grid_update_field() {
let mut test = GridFieldTest::new().await;
let (params, single_select_field) = create_single_select_field(&test.grid_id());
let mut single_select_type_option = SingleSelectTypeOptionPB::from(&single_select_field);
single_select_type_option.options.push(SelectOptionPB::new("Unknown"));
let changeset = FieldChangesetParams {
field_id: single_select_field.id.clone(),
grid_id: test.grid_id(),
frozen: Some(true),
width: Some(1000),
type_option_data: Some(single_select_type_option.protobuf_bytes().to_vec()),
..Default::default()
};
// The expected_field must be equal to the field that applied the changeset
let mut expected_field_rev = single_select_field.clone();
expected_field_rev.frozen = true;
expected_field_rev.width = 1000;
expected_field_rev.insert_type_option_entry(&single_select_type_option);
let scripts = vec![
CreateField { params },
UpdateField { changeset },
AssertFieldEqual {
field_index: test.field_count(),
field_rev: expected_field_rev,
},
];
test.run_scripts(scripts).await;
}
#[tokio::test]
async fn grid_delete_field() {
let mut test = GridFieldTest::new().await;
let original_field_count = test.field_count();
let (params, text_field_rev) = create_text_field(&test.grid_id());
let scripts = vec![
CreateField { params },
DeleteField {
field_rev: text_field_rev,
},
AssertFieldCount(original_field_count),
];
test.run_scripts(scripts).await;
}

81
frontend/rust-lib/flowy-grid/tests/grid/field_test/util.rs Normal file
View File

@ -0,0 +1,81 @@
use flowy_grid::entities::*;
use flowy_grid::services::field::selection_type_option::SelectOptionPB;
use flowy_grid::services::field::*;
use flowy_grid_data_model::revision::*;
pub fn create_text_field(grid_id: &str) -> (InsertFieldParams, FieldRevision) {
let field_rev = FieldBuilder::new(RichTextTypeOptionBuilder::default())
.name("Name")
.visibility(true)
.build();
let cloned_field_rev = field_rev.clone();
let type_option_data = field_rev
.get_type_option_entry::<RichTextTypeOption>(field_rev.field_type_rev)
.unwrap()
.protobuf_bytes()
.to_vec();
let field = GridFieldPB {
id: field_rev.id,
name: field_rev.name,
desc: field_rev.desc,
field_type: field_rev.field_type_rev.into(),
frozen: field_rev.frozen,
visibility: field_rev.visibility,
width: field_rev.width,
is_primary: false,
};
let params = InsertFieldParams {
grid_id: grid_id.to_owned(),
field,
type_option_data,
start_field_id: None,
};
(params, cloned_field_rev)
}
pub fn create_single_select_field(grid_id: &str) -> (InsertFieldParams, FieldRevision) {
let single_select = SingleSelectTypeOptionBuilder::default()
.option(SelectOptionPB::new("Done"))
.option(SelectOptionPB::new("Progress"));
let field_rev = FieldBuilder::new(single_select).name("Name").visibility(true).build();
let cloned_field_rev = field_rev.clone();
let type_option_data = field_rev
.get_type_option_entry::<SingleSelectTypeOptionPB>(field_rev.field_type_rev)
.unwrap()
.protobuf_bytes()
.to_vec();
let field = GridFieldPB {
id: field_rev.id,
name: field_rev.name,
desc: field_rev.desc,
field_type: field_rev.field_type_rev.into(),
frozen: field_rev.frozen,
visibility: field_rev.visibility,
width: field_rev.width,
is_primary: false,
};
let params = InsertFieldParams {
grid_id: grid_id.to_owned(),
field,
type_option_data,
start_field_id: None,
};
(params, cloned_field_rev)
}
// The grid will contains all existing field types and there are three empty rows in this grid.
pub fn make_date_cell_string(s: &str) -> String {
serde_json::to_string(&DateCellChangesetPB {
date: Some(s.to_string()),
time: None,
})
.unwrap()
}

2
frontend/rust-lib/flowy-grid/tests/grid/filter_test/mod.rs Normal file
View File

@ -0,0 +1,2 @@
mod script;
mod text_filter_test;

97
frontend/rust-lib/flowy-grid/tests/grid/filter_test/script.rs Normal file
View File

@ -0,0 +1,97 @@
#![cfg_attr(rustfmt, rustfmt::skip)]
#![allow(clippy::all)]
#![allow(dead_code)]
#![allow(unused_imports)]
use flowy_grid::entities::{CreateGridFilterPayloadPB, GridLayoutType, GridSettingPB};
use flowy_grid::services::setting::GridSettingChangesetBuilder;
use flowy_grid_data_model::revision::{FieldRevision, FieldTypeRevision};
use flowy_sync::entities::grid::{CreateGridFilterParams, DeleteFilterParams, GridSettingChangesetParams};
use crate::grid::grid_editor::GridEditorTest;
pub enum FilterScript {
#[allow(dead_code)]
UpdateGridSetting {
params: GridSettingChangesetParams,
},
InsertGridTableFilter {
payload: CreateGridFilterPayloadPB,
},
AssertTableFilterCount {
count: i32,
},
DeleteGridTableFilter {
filter_id: String,
field_rev: FieldRevision,
},
#[allow(dead_code)]
AssertGridSetting {
expected_setting: GridSettingPB,
},
}
pub struct GridFilterTest {
inner: GridEditorTest,
}
impl GridFilterTest {
pub async fn new() -> Self {
let editor_test = GridEditorTest::new().await;
Self {
inner: editor_test
}
}
pub async fn run_scripts(&mut self, scripts: Vec<FilterScript>) {
for script in scripts {
self.run_script(script).await;
}
}
pub async fn run_script(&mut self, script: FilterScript) {
match script {
FilterScript::UpdateGridSetting { params } => {
let _ = self.editor.update_grid_setting(params).await.unwrap();
}
FilterScript::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();
}
FilterScript::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());
}
FilterScript::DeleteGridTableFilter { filter_id, field_rev} => {
let layout_type = GridLayoutType::Table;
let params = GridSettingChangesetBuilder::new(&self.grid_id, &layout_type)
.delete_filter(DeleteFilterParams { field_id: field_rev.id, filter_id, field_type_rev: field_rev.field_type_rev })
.build();
let _ = self.editor.update_grid_setting(params).await.unwrap();
}
FilterScript::AssertGridSetting { expected_setting } => {
let setting = self.editor.get_grid_setting().await.unwrap();
assert_eq!(expected_setting, setting);
}
}
}
}
impl std::ops::Deref for GridFilterTest {
type Target = GridEditorTest;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl std::ops::DerefMut for GridFilterTest {
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.inner
}
}

51
frontend/rust-lib/flowy-grid/tests/grid/filter_test/text_filter_test.rs Normal file
View File

@ -0,0 +1,51 @@
use crate::grid::filter_test::script::FilterScript::*;
use crate::grid::filter_test::script::*;
use flowy_grid::entities::{CreateGridFilterPayloadPB, 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.get_field_rev(FieldType::RichText);
let payload = CreateGridFilterPayloadPB::new(field_rev, TextFilterCondition::TextIsEmpty, Some("abc".to_owned()));
let scripts = vec![InsertGridTableFilter { payload }, AssertTableFilterCount { count: 1 }];
test.run_scripts(scripts).await;
}
#[tokio::test]
#[should_panic]
async fn grid_filter_invalid_condition_panic_test() {
let mut test = GridFilterTest::new().await;
let field_rev = test.get_field_rev(FieldType::RichText).clone();
// 100 is not a valid condition, so this test should be panic.
let payload = CreateGridFilterPayloadPB::new(&field_rev, 100, Some("".to_owned()));
let scripts = vec![InsertGridTableFilter { payload }];
test.run_scripts(scripts).await;
}
#[tokio::test]
async fn grid_filter_delete_test() {
let mut test = GridFilterTest::new().await;
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;
let filter = test.grid_filters().await.pop().unwrap();
test.run_scripts(vec![
DeleteGridTableFilter {
filter_id: filter.id,
field_rev: field_rev.as_ref().clone(),
},
AssertTableFilterCount { count: 0 },
])
.await;
}
#[tokio::test]
async fn grid_filter_get_rows_test() {}
fn create_filter(field_rev: &FieldRevision, condition: TextFilterCondition, s: &str) -> CreateGridFilterPayloadPB {
CreateGridFilterPayloadPB::new(field_rev, condition, Some(s.to_owned()))
}

258
frontend/rust-lib/flowy-grid/tests/grid/grid_editor.rs Normal file
View File

@ -0,0 +1,258 @@
#![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::SelectOptionPB;
use flowy_grid::services::field::*;
use flowy_grid::services::grid_editor::{GridPadBuilder, GridRevisionEditor};
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;
use flowy_sync::client_grid::GridBuilder;
use flowy_sync::entities::grid::{
CreateGridFilterParams, DeleteFilterParams, FieldChangesetParams, GridSettingChangesetParams,
};
use flowy_test::helper::ViewTest;
use flowy_test::FlowySDKTest;
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 {
pub sdk: FlowySDKTest,
pub grid_id: String,
pub editor: Arc<GridRevisionEditor>,
pub field_revs: Vec<Arc<FieldRevision>>,
pub block_meta_revs: Vec<Arc<GridBlockMetaRevision>>,
pub row_revs: Vec<Arc<RowRevision>>,
pub field_count: usize,
pub row_order_by_row_id: HashMap<String, GridRowPB>,
}
impl GridEditorTest {
pub async fn new() -> Self {
let sdk = FlowySDKTest::default();
let _ = sdk.init_user().await;
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!(block_meta_revs.len(), 1);
// It seems like you should add the field in the make_test_grid() function.
// Because we assert the initialize count of the fields is equal to FieldType::COUNT.
assert_eq!(field_revs.len(), FieldType::COUNT);
let grid_id = test.view.id;
Self {
sdk,
grid_id,
editor,
field_revs,
block_meta_revs,
row_revs,
field_count: FieldType::COUNT,
row_order_by_row_id: HashMap::default(),
}
}
pub async fn get_row_revs(&self) -> Vec<Arc<RowRevision>> {
self.editor
.grid_block_snapshots(None)
.await
.unwrap()
.pop()
.unwrap()
.row_revs
}
pub async fn grid_filters(&self) -> Vec<GridFilter> {
let layout_type = GridLayoutType::Table;
self.editor.get_grid_filter(&layout_type).await.unwrap()
}
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 == field_type
})
.collect::<Vec<_>>()
.pop()
.unwrap()
}
pub fn block_id(&self) -> &str {
&self.block_meta_revs.last().unwrap().block_id
}
}
pub const GOOGLE: &str = "Google";
pub const FACEBOOK: &str = "Facebook";
pub const TWITTER: &str = "Twitter";
pub const COMPLETED: &str = "Completed";
pub const PLANNED: &str = "Planned";
pub const PAUSED: &str = "Paused";
// 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;
// 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(SelectOptionPB::new(COMPLETED))
.option(SelectOptionPB::new(PLANNED))
.option(SelectOptionPB::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(SelectOptionPB::new(GOOGLE))
.option(SelectOptionPB::new(FACEBOOK))
.option(SelectOptionPB::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 urgent").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);
}
}
}
// We have many assumptions base on the number of the rows, so do not change the number of the loop.
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);
}
grid_builder.build()
}

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

@ -1,2 +1,5 @@
mod grid_test;
mod script;
mod block_test;
mod cell_test;
mod field_test;
mod filter_test;
mod grid_editor;