mirror of
https://github.com/AppFlowy-IO/AppFlowy.git
synced 2025-10-30 17:38:40 +00:00
61fd608200
* refactor: rename structs * chore: read database id from view * chore: fix open database error because of create a database view for database id * chore: fix tests * chore: rename datbase id to view id in flutter * refactor: move grid and board to database view folder * refactor: rename functions * refactor: move calender to datbase view folder * refactor: rename app_flowy to appflowy_flutter * chore: reanming * chore: fix freeze gen * chore: remove todos * refactor: view process events * chore: add link database test * chore: just open view if there is opened database
770 lines
17 KiB
Rust
770 lines
17 KiB
Rust
use crate::node::script::NodeScript::*;
|
|
use crate::node::script::{make_node_delta_changeset, NodeTest};
|
|
|
|
use lib_ot::core::{NodeData, NodeDataBuilder, Path};
|
|
|
|
#[test]
|
|
fn node_insert_test() {
|
|
let mut test = NodeTest::new();
|
|
let node_data = NodeData::new("text");
|
|
let path: Path = vec![0].into();
|
|
let scripts = vec![
|
|
InsertNode {
|
|
path: path.clone(),
|
|
node_data: node_data.clone(),
|
|
rev_id: 1,
|
|
},
|
|
AssertNode {
|
|
path,
|
|
expected: Some(node_data),
|
|
},
|
|
];
|
|
test.run_scripts(scripts);
|
|
}
|
|
|
|
#[test]
|
|
#[should_panic]
|
|
fn node_insert_with_empty_path_test() {
|
|
let mut test = NodeTest::new();
|
|
let scripts = vec![InsertNode {
|
|
path: vec![].into(),
|
|
node_data: NodeData::new("text"),
|
|
rev_id: 1,
|
|
}];
|
|
test.run_scripts(scripts);
|
|
}
|
|
|
|
#[test]
|
|
fn tree_insert_multiple_nodes_at_root_path_test() {
|
|
let mut test = NodeTest::new();
|
|
let node_1 = NodeData::new("a");
|
|
let node_2 = NodeData::new("b");
|
|
let node_3 = NodeData::new("c");
|
|
let node_data_list = vec![node_1, node_2, node_3];
|
|
let path: Path = vec![0].into();
|
|
|
|
// Insert three nodes under the root
|
|
let scripts = vec![
|
|
// 0:a
|
|
// 1:b
|
|
// 2:c
|
|
InsertNodes {
|
|
path,
|
|
node_data_list: node_data_list.clone(),
|
|
rev_id: 1,
|
|
},
|
|
AssertNodesAtRoot {
|
|
expected: node_data_list,
|
|
},
|
|
];
|
|
test.run_scripts(scripts);
|
|
}
|
|
|
|
#[test]
|
|
fn tree_insert_multiple_nodes_at_root_path_test2() {
|
|
let mut test = NodeTest::new();
|
|
let node_1 = NodeData::new("a");
|
|
let node_2 = NodeData::new("b");
|
|
let node_3 = NodeData::new("c");
|
|
let scripts = vec![
|
|
InsertNode {
|
|
path: 0.into(),
|
|
node_data: node_1.clone(),
|
|
rev_id: 1,
|
|
},
|
|
InsertNode {
|
|
path: 1.into(),
|
|
node_data: node_2.clone(),
|
|
rev_id: 2,
|
|
},
|
|
InsertNode {
|
|
path: 2.into(),
|
|
node_data: node_3.clone(),
|
|
rev_id: 3,
|
|
},
|
|
// 0:a
|
|
// 1:b
|
|
// 2:c
|
|
AssertNode {
|
|
path: 0.into(),
|
|
expected: Some(node_1),
|
|
},
|
|
AssertNode {
|
|
path: 1.into(),
|
|
expected: Some(node_2),
|
|
},
|
|
AssertNode {
|
|
path: 2.into(),
|
|
expected: Some(node_3),
|
|
},
|
|
];
|
|
test.run_scripts(scripts);
|
|
}
|
|
|
|
#[test]
|
|
fn node_insert_node_with_children_test() {
|
|
let mut test = NodeTest::new();
|
|
let image_1 = NodeData::new("image_a");
|
|
let image_2 = NodeData::new("image_b");
|
|
|
|
let image = NodeDataBuilder::new("image")
|
|
.add_node_data(image_1.clone())
|
|
.add_node_data(image_2.clone())
|
|
.build();
|
|
let node_data = NodeDataBuilder::new("text")
|
|
.add_node_data(image.clone())
|
|
.build();
|
|
let path: Path = 0.into();
|
|
let scripts = vec![
|
|
InsertNode {
|
|
path: path.clone(),
|
|
node_data: node_data.clone(),
|
|
rev_id: 1,
|
|
},
|
|
// 0:text
|
|
// 0:image
|
|
// 0:image_1
|
|
// 1:image_2
|
|
AssertNode {
|
|
path,
|
|
expected: Some(node_data),
|
|
},
|
|
AssertNode {
|
|
path: vec![0, 0].into(),
|
|
expected: Some(image),
|
|
},
|
|
AssertNode {
|
|
path: vec![0, 0, 0].into(),
|
|
expected: Some(image_1),
|
|
},
|
|
AssertNode {
|
|
path: vec![0, 0, 1].into(),
|
|
expected: Some(image_2),
|
|
},
|
|
];
|
|
test.run_scripts(scripts);
|
|
}
|
|
|
|
#[test]
|
|
fn node_insert_node_in_ordered_nodes_test() {
|
|
let mut test = NodeTest::new();
|
|
let path_1: Path = 0.into();
|
|
let node_1 = NodeData::new("text_1");
|
|
|
|
let path_2: Path = 1.into();
|
|
let node_2_1 = NodeData::new("text_2_1");
|
|
let node_2_2 = NodeData::new("text_2_2");
|
|
|
|
let path_3: Path = 2.into();
|
|
let node_3 = NodeData::new("text_3");
|
|
|
|
let scripts = vec![
|
|
InsertNode {
|
|
path: path_1.clone(),
|
|
node_data: node_1.clone(),
|
|
rev_id: 1,
|
|
},
|
|
InsertNode {
|
|
path: path_2.clone(),
|
|
node_data: node_2_1.clone(),
|
|
rev_id: 2,
|
|
},
|
|
InsertNode {
|
|
path: path_3.clone(),
|
|
node_data: node_3,
|
|
rev_id: 3,
|
|
},
|
|
// 0:text_1
|
|
// 1:text_2_1
|
|
// 2:text_3
|
|
InsertNode {
|
|
path: path_2.clone(),
|
|
node_data: node_2_2.clone(),
|
|
rev_id: 4,
|
|
},
|
|
// 0:text_1
|
|
// 1:text_2_2
|
|
// 2:text_2_1
|
|
// 3:text_3
|
|
AssertNode {
|
|
path: path_1,
|
|
expected: Some(node_1),
|
|
},
|
|
AssertNode {
|
|
path: path_2,
|
|
expected: Some(node_2_2),
|
|
},
|
|
AssertNode {
|
|
path: path_3,
|
|
expected: Some(node_2_1),
|
|
},
|
|
AssertNumberOfChildrenAtPath {
|
|
path: None,
|
|
expected: 4,
|
|
},
|
|
];
|
|
test.run_scripts(scripts);
|
|
}
|
|
|
|
#[test]
|
|
fn node_insert_nested_nodes_test() {
|
|
let mut test = NodeTest::new();
|
|
let node_data_1_1 = NodeDataBuilder::new("text_1_1").build();
|
|
let node_data_1_2 = NodeDataBuilder::new("text_1_2").build();
|
|
let node_data_1 = NodeDataBuilder::new("text_1")
|
|
.add_node_data(node_data_1_1.clone())
|
|
.add_node_data(node_data_1_2.clone())
|
|
.build();
|
|
|
|
let node_data_2_1 = NodeDataBuilder::new("text_2_1").build();
|
|
let node_data_2_2 = NodeDataBuilder::new("text_2_2").build();
|
|
let node_data_2 = NodeDataBuilder::new("text_2")
|
|
.add_node_data(node_data_2_1.clone())
|
|
.add_node_data(node_data_2_2.clone())
|
|
.build();
|
|
|
|
let scripts = vec![
|
|
InsertNode {
|
|
path: 0.into(),
|
|
node_data: node_data_1,
|
|
rev_id: 1,
|
|
},
|
|
InsertNode {
|
|
path: 1.into(),
|
|
node_data: node_data_2,
|
|
rev_id: 2,
|
|
},
|
|
// the tree will be:
|
|
// 0:text_1
|
|
// 0:text_1_1
|
|
// 1:text_1_2
|
|
// 1:text_2
|
|
// 0:text_2_1
|
|
// 1:text_2_2
|
|
AssertNode {
|
|
path: vec![0, 0].into(),
|
|
expected: Some(node_data_1_1),
|
|
},
|
|
AssertNode {
|
|
path: vec![0, 1].into(),
|
|
expected: Some(node_data_1_2),
|
|
},
|
|
AssertNode {
|
|
path: vec![1, 0].into(),
|
|
expected: Some(node_data_2_1),
|
|
},
|
|
AssertNode {
|
|
path: vec![1, 1].into(),
|
|
expected: Some(node_data_2_2),
|
|
},
|
|
];
|
|
test.run_scripts(scripts);
|
|
}
|
|
|
|
#[test]
|
|
fn node_insert_node_before_existing_nested_nodes_test() {
|
|
let mut test = NodeTest::new();
|
|
let node_data_1_1 = NodeDataBuilder::new("text_1_1").build();
|
|
let node_data_1_2 = NodeDataBuilder::new("text_1_2").build();
|
|
let node_data_1 = NodeDataBuilder::new("text_1")
|
|
.add_node_data(node_data_1_1.clone())
|
|
.add_node_data(node_data_1_2.clone())
|
|
.build();
|
|
|
|
let scripts = vec![
|
|
InsertNode {
|
|
path: 0.into(),
|
|
node_data: node_data_1,
|
|
rev_id: 1,
|
|
},
|
|
// 0:text_1
|
|
// 0:text_1_1
|
|
// 1:text_1_2
|
|
InsertNode {
|
|
path: 0.into(),
|
|
node_data: NodeDataBuilder::new("text_0").build(),
|
|
rev_id: 2,
|
|
},
|
|
// 0:text_0
|
|
// 1:text_1
|
|
// 0:text_1_1
|
|
// 1:text_1_2
|
|
AssertNode {
|
|
path: vec![1, 0].into(),
|
|
expected: Some(node_data_1_1),
|
|
},
|
|
AssertNode {
|
|
path: vec![1, 1].into(),
|
|
expected: Some(node_data_1_2),
|
|
},
|
|
];
|
|
test.run_scripts(scripts);
|
|
}
|
|
#[test]
|
|
fn node_insert_with_attributes_test() {
|
|
let mut test = NodeTest::new();
|
|
let path: Path = 0.into();
|
|
let mut inserted_node = NodeData::new("text");
|
|
inserted_node.attributes.insert("bold", true);
|
|
inserted_node.attributes.insert("underline", true);
|
|
|
|
let scripts = vec![
|
|
InsertNode {
|
|
path: path.clone(),
|
|
node_data: inserted_node.clone(),
|
|
rev_id: 1,
|
|
},
|
|
UpdateAttributes {
|
|
path: path.clone(),
|
|
attributes: inserted_node.attributes.clone(),
|
|
},
|
|
AssertNode {
|
|
path,
|
|
expected: Some(inserted_node),
|
|
},
|
|
];
|
|
test.run_scripts(scripts);
|
|
}
|
|
|
|
#[test]
|
|
fn node_delete_test() {
|
|
let mut test = NodeTest::new();
|
|
let inserted_node = NodeData::new("text");
|
|
let path: Path = 0.into();
|
|
let scripts = vec![
|
|
InsertNode {
|
|
path: path.clone(),
|
|
node_data: inserted_node,
|
|
rev_id: 1,
|
|
},
|
|
DeleteNode {
|
|
path: path.clone(),
|
|
rev_id: 2,
|
|
},
|
|
AssertNode {
|
|
path,
|
|
expected: None,
|
|
},
|
|
];
|
|
test.run_scripts(scripts);
|
|
}
|
|
|
|
#[test]
|
|
fn nodes_delete_test() {
|
|
let mut test = NodeTest::new();
|
|
let node_1 = NodeData::new("a");
|
|
let node_2 = NodeData::new("b");
|
|
let node_3 = NodeData::new("c");
|
|
let node_data_list = vec![node_1, node_2, node_3];
|
|
let path: Path = 0.into();
|
|
let scripts = vec![
|
|
InsertNodes {
|
|
path: path.clone(),
|
|
node_data_list: node_data_list.clone(),
|
|
rev_id: 1,
|
|
},
|
|
DeleteNodes {
|
|
path: path.clone(),
|
|
node_data_list,
|
|
rev_id: 2,
|
|
},
|
|
AssertNode {
|
|
path: path.clone(),
|
|
expected: None,
|
|
},
|
|
AssertNode {
|
|
path: path.next(),
|
|
expected: None,
|
|
},
|
|
AssertNode {
|
|
path: path.next().next(),
|
|
expected: None,
|
|
},
|
|
AssertTreeJSON {
|
|
expected: r#""""#.to_string(),
|
|
},
|
|
];
|
|
test.run_scripts(scripts);
|
|
}
|
|
|
|
#[test]
|
|
fn node_delete_node_from_list_test() {
|
|
let mut test = NodeTest::new();
|
|
let image_a = NodeData::new("image_a");
|
|
let image_b = NodeData::new("image_b");
|
|
|
|
let image_1 = NodeDataBuilder::new("image_1")
|
|
.add_node_data(image_a.clone())
|
|
.add_node_data(image_b.clone())
|
|
.build();
|
|
let text_node_1 = NodeDataBuilder::new("text_1")
|
|
.add_node_data(image_1)
|
|
.build();
|
|
let image_2 = NodeDataBuilder::new("image_2")
|
|
.add_node_data(image_a)
|
|
.add_node_data(image_b)
|
|
.build();
|
|
let text_node_2 = NodeDataBuilder::new("text_2")
|
|
.add_node_data(image_2.clone())
|
|
.build();
|
|
|
|
let scripts = vec![
|
|
InsertNode {
|
|
path: 0.into(),
|
|
node_data: text_node_1,
|
|
rev_id: 1,
|
|
},
|
|
InsertNode {
|
|
path: 1.into(),
|
|
node_data: text_node_2.clone(),
|
|
rev_id: 2,
|
|
},
|
|
DeleteNode {
|
|
path: 0.into(),
|
|
rev_id: 3,
|
|
},
|
|
AssertNode {
|
|
path: 1.into(),
|
|
expected: None,
|
|
},
|
|
AssertNode {
|
|
path: 0.into(),
|
|
expected: Some(text_node_2),
|
|
},
|
|
AssertNode {
|
|
path: vec![0, 0].into(),
|
|
expected: Some(image_2),
|
|
},
|
|
];
|
|
test.run_scripts(scripts);
|
|
}
|
|
|
|
#[test]
|
|
fn node_delete_nested_node_test() {
|
|
let mut test = NodeTest::new();
|
|
let image_a = NodeData::new("image_a");
|
|
let image_b = NodeData::new("image_b");
|
|
|
|
let image_1 = NodeDataBuilder::new("image_1")
|
|
.add_node_data(image_a.clone())
|
|
.add_node_data(image_b.clone())
|
|
.build();
|
|
let text_node_1 = NodeDataBuilder::new("text_1")
|
|
.add_node_data(image_1)
|
|
.build();
|
|
|
|
let image_2 = NodeDataBuilder::new("image_2")
|
|
.add_node_data(image_a.clone())
|
|
.add_node_data(image_b.clone())
|
|
.build();
|
|
let text_node_2 = NodeDataBuilder::new("text_2")
|
|
.add_node_data(image_2)
|
|
.build();
|
|
|
|
let scripts = vec![
|
|
InsertNode {
|
|
path: 0.into(),
|
|
node_data: text_node_1,
|
|
rev_id: 1,
|
|
},
|
|
InsertNode {
|
|
path: 1.into(),
|
|
node_data: text_node_2,
|
|
rev_id: 2,
|
|
},
|
|
// 0:text_1
|
|
// 0:image_1
|
|
// 0:image_a
|
|
// 1:image_b
|
|
// 1:text_2
|
|
// 0:image_2
|
|
// 0:image_a
|
|
// 1:image_b
|
|
DeleteNode {
|
|
path: vec![0, 0, 0].into(),
|
|
rev_id: 3,
|
|
},
|
|
// 0:text_1
|
|
// 0:image_1
|
|
// 0:image_b
|
|
// 1:text_2
|
|
// 0:image_2
|
|
// 0:image_a
|
|
// 1:image_b
|
|
AssertNode {
|
|
path: vec![0, 0, 0].into(),
|
|
expected: Some(image_b.clone()),
|
|
},
|
|
DeleteNode {
|
|
path: vec![0, 0].into(),
|
|
rev_id: 4,
|
|
},
|
|
// 0:text_1
|
|
// 1:text_2
|
|
// 0:image_2
|
|
// 0:image_a
|
|
// 1:image_b
|
|
AssertNumberOfChildrenAtPath {
|
|
path: Some(0.into()),
|
|
expected: 0,
|
|
},
|
|
AssertNode {
|
|
path: vec![0].into(),
|
|
expected: Some(NodeDataBuilder::new("text_1").build()),
|
|
},
|
|
AssertNode {
|
|
path: vec![1, 0, 0].into(),
|
|
expected: Some(image_a),
|
|
},
|
|
AssertNode {
|
|
path: vec![1, 0, 1].into(),
|
|
expected: Some(image_b),
|
|
},
|
|
];
|
|
test.run_scripts(scripts);
|
|
}
|
|
|
|
#[test]
|
|
fn node_delete_children_test() {
|
|
let mut test = NodeTest::new();
|
|
let inserted_node = NodeDataBuilder::new("text")
|
|
.add_node_data(NodeDataBuilder::new("sub_text_1").build())
|
|
.add_node_data(NodeDataBuilder::new("sub_text_2").build())
|
|
.add_node_data(NodeDataBuilder::new("sub_text_3").build())
|
|
.build();
|
|
|
|
let scripts = vec![
|
|
InsertNode {
|
|
path: vec![0].into(),
|
|
node_data: inserted_node,
|
|
rev_id: 1,
|
|
},
|
|
AssertNode {
|
|
path: vec![0, 0].into(),
|
|
expected: Some(NodeDataBuilder::new("sub_text_1").build()),
|
|
},
|
|
AssertNode {
|
|
path: vec![0, 1].into(),
|
|
expected: Some(NodeDataBuilder::new("sub_text_2").build()),
|
|
},
|
|
AssertNode {
|
|
path: vec![0, 2].into(),
|
|
expected: Some(NodeDataBuilder::new("sub_text_3").build()),
|
|
},
|
|
AssertNumberOfChildrenAtPath {
|
|
path: Some(Path(vec![0])),
|
|
expected: 3,
|
|
},
|
|
DeleteNode {
|
|
path: vec![0, 0].into(),
|
|
rev_id: 2,
|
|
},
|
|
AssertNode {
|
|
path: vec![0, 0].into(),
|
|
expected: Some(NodeDataBuilder::new("sub_text_2").build()),
|
|
},
|
|
AssertNumberOfChildrenAtPath {
|
|
path: Some(Path(vec![0])),
|
|
expected: 2,
|
|
},
|
|
];
|
|
test.run_scripts(scripts);
|
|
}
|
|
|
|
#[test]
|
|
fn node_reorder_sub_nodes_test() {
|
|
let mut test = NodeTest::new();
|
|
let image_a = NodeData::new("image_a");
|
|
let image_b = NodeData::new("image_b");
|
|
|
|
let child_1 = NodeDataBuilder::new("image_1")
|
|
.add_node_data(image_a.clone())
|
|
.add_node_data(image_b.clone())
|
|
.build();
|
|
let text_node_1 = NodeDataBuilder::new("text_1")
|
|
.add_node_data(child_1)
|
|
.build();
|
|
let scripts = vec![
|
|
InsertNode {
|
|
path: 0.into(),
|
|
node_data: text_node_1,
|
|
rev_id: 1,
|
|
},
|
|
// 0:text_1
|
|
// 0:image_1
|
|
// 0:image_a
|
|
// 1:image_b
|
|
DeleteNode {
|
|
path: vec![0, 0, 0].into(),
|
|
rev_id: 2,
|
|
},
|
|
// 0:text_1
|
|
// 0:image_1
|
|
// 0:image_b
|
|
InsertNode {
|
|
path: vec![0, 0, 1].into(),
|
|
node_data: image_a.clone(),
|
|
rev_id: 3,
|
|
},
|
|
// 0:text_1
|
|
// 0:image_1
|
|
// 0:image_b
|
|
// 1:image_a
|
|
AssertNode {
|
|
path: vec![0, 0, 0].into(),
|
|
expected: Some(image_b),
|
|
},
|
|
AssertNode {
|
|
path: vec![0, 0, 1].into(),
|
|
expected: Some(image_a),
|
|
},
|
|
];
|
|
test.run_scripts(scripts);
|
|
}
|
|
|
|
#[test]
|
|
fn node_reorder_nodes_test() {
|
|
let mut test = NodeTest::new();
|
|
let image_a = NodeData::new("image_a");
|
|
let image_b = NodeData::new("image_b");
|
|
|
|
let image_1 = NodeDataBuilder::new("image_1")
|
|
.add_node_data(image_a.clone())
|
|
.add_node_data(image_b.clone())
|
|
.build();
|
|
let text_node_1 = NodeDataBuilder::new("text_1")
|
|
.add_node_data(image_1.clone())
|
|
.build();
|
|
|
|
let image_2 = NodeDataBuilder::new("image_2")
|
|
.add_node_data(image_a.clone())
|
|
.add_node_data(image_b.clone())
|
|
.build();
|
|
let text_node_2 = NodeDataBuilder::new("text_2")
|
|
.add_node_data(image_2.clone())
|
|
.build();
|
|
|
|
let scripts = vec![
|
|
InsertNode {
|
|
path: 0.into(),
|
|
node_data: text_node_1.clone(),
|
|
rev_id: 1,
|
|
},
|
|
InsertNode {
|
|
path: 0.into(),
|
|
node_data: text_node_2.clone(),
|
|
rev_id: 1,
|
|
},
|
|
// 0:text_1
|
|
// 0:image_1
|
|
// 0:image_a
|
|
// 1:image_b
|
|
// 1:text_2
|
|
// 0:image_2
|
|
// 0:image_a
|
|
// 1:image_b
|
|
DeleteNode {
|
|
path: vec![0].into(),
|
|
rev_id: 3,
|
|
},
|
|
AssertNode {
|
|
path: vec![0].into(),
|
|
expected: Some(text_node_2.clone()),
|
|
},
|
|
InsertNode {
|
|
path: vec![1].into(),
|
|
node_data: text_node_1.clone(),
|
|
rev_id: 4,
|
|
},
|
|
// 0:text_2
|
|
// 0:image_2
|
|
// 0:image_a
|
|
// 1:image_b
|
|
// 1:text_1
|
|
// 0:image_1
|
|
// 0:image_a
|
|
// 1:image_b
|
|
AssertNode {
|
|
path: vec![0].into(),
|
|
expected: Some(text_node_2),
|
|
},
|
|
AssertNode {
|
|
path: vec![0, 0].into(),
|
|
expected: Some(image_2),
|
|
},
|
|
AssertNode {
|
|
path: vec![0, 0, 0].into(),
|
|
expected: Some(image_a),
|
|
},
|
|
AssertNode {
|
|
path: vec![1].into(),
|
|
expected: Some(text_node_1),
|
|
},
|
|
AssertNode {
|
|
path: vec![1, 0].into(),
|
|
expected: Some(image_1),
|
|
},
|
|
AssertNode {
|
|
path: vec![1, 0, 1].into(),
|
|
expected: Some(image_b),
|
|
},
|
|
];
|
|
test.run_scripts(scripts);
|
|
}
|
|
|
|
#[test]
|
|
fn node_update_body_test() {
|
|
let mut test = NodeTest::new();
|
|
let (initial_delta, changeset, expected) = make_node_delta_changeset("Hello", "AppFlowy");
|
|
let node = NodeDataBuilder::new("text")
|
|
.insert_delta(initial_delta)
|
|
.build();
|
|
|
|
let scripts = vec![
|
|
InsertNode {
|
|
path: 0.into(),
|
|
node_data: node,
|
|
rev_id: 1,
|
|
},
|
|
UpdateBody {
|
|
path: 0.into(),
|
|
changeset,
|
|
},
|
|
AssertNodeDelta {
|
|
path: 0.into(),
|
|
expected,
|
|
},
|
|
];
|
|
test.run_scripts(scripts);
|
|
}
|
|
|
|
#[test]
|
|
fn node_inverted_body_changeset_test() {
|
|
let mut test = NodeTest::new();
|
|
let (initial_delta, changeset, _expected) = make_node_delta_changeset("Hello", "AppFlowy");
|
|
let node = NodeDataBuilder::new("text")
|
|
.insert_delta(initial_delta.clone())
|
|
.build();
|
|
|
|
let scripts = vec![
|
|
InsertNode {
|
|
path: 0.into(),
|
|
node_data: node,
|
|
rev_id: 1,
|
|
},
|
|
UpdateBody {
|
|
path: 0.into(),
|
|
changeset: changeset.clone(),
|
|
},
|
|
UpdateBody {
|
|
path: 0.into(),
|
|
changeset: changeset.inverted(),
|
|
},
|
|
AssertNodeDelta {
|
|
path: 0.into(),
|
|
expected: initial_delta,
|
|
},
|
|
];
|
|
test.run_scripts(scripts);
|
|
}
|