#![cfg(feature = "extension")]
use crate::json::{Object, Value};
use crate::{
LexicalExtension, NormalizedPeerDependency, declare_peer_dependency, define_extension,
};
use std::rc::Rc;
#[test]
fn does_not_change_identity() {
let extension_arg: LexicalExtension<(), (), ()> = LexicalExtension::new("test", ());
let name_buffer = extension_arg.name.as_ptr();
let extension: Rc<LexicalExtension<(), (), ()>> = define_extension(extension_arg);
assert_eq!(extension.name.as_ptr(), name_buffer);
assert_eq!(extension.name, "test");
}
#[test]
fn infers_the_expected_type_base_case() {
let extension: Rc<LexicalExtension<(), (), ()>> =
define_extension(LexicalExtension::new("test", ()));
assert_eq!(extension.name, "test");
}
#[test]
fn infers_the_expected_type_config_inference() {
let mut config = Object::new();
config.insert("number", Value::from(123.0));
let extension: Rc<LexicalExtension<Object, (), ()>> =
define_extension(LexicalExtension::new("test", config));
assert_eq!(extension.config.get("number"), Some(&Value::from(123.0)));
}
#[cfg(feature = "extension")]
#[test]
fn infers_the_expected_type_output_inference() {
use crate::extension::{build_editor_from_extensions, get_extension_dependency_from_editor};
struct Output {
output: i32,
}
let extension: Rc<LexicalExtension<(), Output, ()>> = define_extension(LexicalExtension {
build: Some(Rc::new(|_, _, _| Ok(Output { output: 321 }))),
..LexicalExtension::new("test", ())
});
let editor = build_editor_from_extensions([extension.clone().into()]).unwrap();
let dep = get_extension_dependency_from_editor(&editor, &extension).unwrap();
assert_eq!(dep.output.unwrap().output, 321);
editor.dispose();
}
#[test]
fn can_define_an_extension_without_config() {
let extension: Rc<LexicalExtension<(), (), ()>> =
define_extension(LexicalExtension::new("test", ()));
assert_eq!(extension.config, ());
}
#[test]
fn infers_the_correct_init_type() {
let extension: Rc<LexicalExtension<(), (), &'static str>> =
define_extension(LexicalExtension {
init: Some(Rc::new(|_, _, _| Ok("string"))),
..LexicalExtension::new("test", ())
});
assert!(extension.init.is_some());
}
#[test]
fn declare_peer_dependency_validates_the_type_argument() {
let dep: NormalizedPeerDependency = declare_peer_dependency::<Object>("other", None);
assert_eq!(dep.name(), "other");
assert!(dep.config.is_none());
let mut other = Object::new();
other.insert("other", Value::Bool(false));
let configured = declare_peer_dependency::<Object>("other", Some(other.clone()));
assert_eq!(configured.name(), "other");
assert_eq!(
configured
.config
.as_ref()
.and_then(|c| c.downcast_ref::<Object>()),
Some(&other)
);
}