AppFlowy/shared-lib/lib-ot/tests/node/changeset_compose_test.rs

use crate::node::script::NodeScript::*;
use crate::node::script::NodeTest;
use lib_ot::core::{AttributeEntry, Changeset, NodeData, OperationTransform};
use lib_ot::text_delta::DeltaTextOperationBuilder;

#[test]
fn changeset_delta_compose_delta_test() {
  // delta 1
  let delta_1 = DeltaTextOperationBuilder::new()
    .insert("Hello world")
    .build();
  let inverted_1 = delta_1.inverted();
  let mut changeset_1 = Changeset::Delta {
    delta: delta_1.clone(),
    inverted: inverted_1,
  };

  // delta 2
  let delta_2 = DeltaTextOperationBuilder::new()
    .retain(delta_1.utf16_target_len)
    .insert("!")
    .build();
  let inverted_2 = delta_2.inverted();
  let changeset_2 = Changeset::Delta {
    delta: delta_2,
    inverted: inverted_2,
  };

  // compose
  changeset_1.compose(&changeset_2).unwrap();

  if let Changeset::Delta { delta, inverted } = changeset_1 {
    assert_eq!(delta.content().unwrap(), "Hello world!");
    let new_delta = delta.compose(&inverted).unwrap();
    assert_eq!(new_delta.content().unwrap(), "");
  }
}

#[test]
fn operation_compose_delta_changeset_then_invert_test() {
  let delta = DeltaTextOperationBuilder::new()
    .insert("Hello world")
    .build();
  let inverted = delta.inverted();
  let changeset = Changeset::Delta {
    delta: delta.clone(),
    inverted: inverted.clone(),
  };

  let mut test = NodeTest::new();
  let text_node = NodeData::new("text");
  let scripts = vec![
    InsertNode {
      path: 0.into(),
      node_data: text_node,
      rev_id: 1,
    },
    UpdateBody {
      path: 0.into(),
      changeset: changeset.clone(),
    },
    AssertNodeDelta {
      path: 0.into(),
      expected: delta.clone(),
    },
    UpdateBody {
      path: 0.into(),
      changeset: changeset.inverted(),
    },
    AssertNodeDelta {
      path: 0.into(),
      expected: delta.compose(&inverted).unwrap(),
    },
  ];
  test.run_scripts(scripts);
}

#[test]
fn operation_compose_multiple_delta_changeset_then_invert_test() {
  // delta 1
  let delta_1 = DeltaTextOperationBuilder::new()
    .insert("Hello world")
    .build();
  let inverted_1 = delta_1.inverted();
  let changeset_1 = Changeset::Delta {
    delta: delta_1.clone(),
    inverted: inverted_1,
  };

  // delta 2
  let delta_2 = DeltaTextOperationBuilder::new()
    .retain(delta_1.utf16_target_len)
    .insert("!")
    .build();
  let inverted_2 = delta_2.inverted();
  let changeset_2 = Changeset::Delta {
    delta: delta_2.clone(),
    inverted: inverted_2,
  };

  // delta 3
  let delta_3 = DeltaTextOperationBuilder::new()
    .retain(delta_2.utf16_target_len)
    .insert("AppFlowy")
    .build();
  let inverted_3 = delta_3.inverted();
  let changeset_3 = Changeset::Delta {
    delta: delta_3.clone(),
    inverted: inverted_3,
  };

  let mut test = NodeTest::new();
  let text_node = NodeData::new("text");
  let scripts = vec![
    InsertNode {
      path: 0.into(),
      node_data: text_node,
      rev_id: 1,
    },
    UpdateBody {
      path: 0.into(),
      changeset: changeset_1.clone(),
    },
    UpdateBody {
      path: 0.into(),
      changeset: changeset_2.clone(),
    },
    UpdateBody {
      path: 0.into(),
      changeset: changeset_3.clone(),
    },
    AssertNodeDelta {
      path: 0.into(),
      expected: delta_1
        .compose(&delta_2)
        .unwrap()
        .compose(&delta_3)
        .unwrap(),
    },
    UpdateBody {
      path: 0.into(),
      changeset: changeset_3.inverted(),
    },
    AssertNodeDeltaContent {
      path: 0.into(),
      expected: r#"Hello world!"#,
    },
    UpdateBody {
      path: 0.into(),
      changeset: changeset_2.inverted(),
    },
    AssertNodeDeltaContent {
      path: 0.into(),
      expected: r#"Hello world"#,
    },
    UpdateBody {
      path: 0.into(),
      changeset: changeset_1.inverted(),
    },
    AssertNodeDeltaContent {
      path: 0.into(),
      expected: r#""#,
    },
  ];
  test.run_scripts(scripts);
}

#[test]
#[should_panic]
fn changeset_delta_compose_attributes_test() {
  // delta 1
  let delta = DeltaTextOperationBuilder::new()
    .insert("Hello world")
    .build();
  let inverted = delta.inverted();
  let mut delta_changeset = Changeset::Delta { delta, inverted };

  // attributes
  let attribute_changeset = Changeset::Attributes {
    new: Default::default(),
    old: Default::default(),
  };

  // compose
  delta_changeset.compose(&attribute_changeset).unwrap();
}

#[test]
fn changeset_attributes_compose_attributes_test() {
  // attributes
  let mut changeset_1 = Changeset::Attributes {
    new: AttributeEntry::new("bold", true).into(),
    old: Default::default(),
  };

  let changeset_2 = Changeset::Attributes {
    new: AttributeEntry::new("Italic", true).into(),
    old: Default::default(),
  };
  // compose
  changeset_1.compose(&changeset_2).unwrap();

  if let Changeset::Attributes { new, old: _ } = changeset_1 {
    assert_eq!(new, AttributeEntry::new("Italic", true).into());
  }
}