#![cfg(feature = "runtime-templates")]
extern crate light_fw_core as light_fw;
use std::any::Any;
use light_fw::component::Component;
use light_fw::vdom::{Event, NodeKind, VElement};
struct Empty;
impl Component for Empty {
fn render(&self) -> VElement {
VElement::container("", NodeKind::Column, Vec::new())
}
fn as_any_mut(&mut self) -> &mut dyn Any {
self
}
}
#[test]
fn empty_html_gives_empty_column() {
let c = Empty;
let el = light_fw::runtime::parse_template("", &c).expect("parse");
assert_eq!(el.kind, NodeKind::Column);
assert!(el.children.is_empty());
}
#[test]
fn div_with_bare_text() {
let c = Empty;
let el = light_fw::runtime::parse_template(
r#"<window title="t" width="100" height="80"><div>Hi</div></window>"#,
&c,
)
.expect("parse");
assert_eq!(el.children.len(), 1);
let inner = &el.children[0];
assert_eq!(inner.kind, NodeKind::Column);
assert_eq!(inner.children.len(), 1);
matches!(&inner.children[0].kind, NodeKind::Text { content } if content == "Hi");
}
#[test]
fn button_element() {
let c = Empty;
let el = light_fw::runtime::parse_template(
r#"<window title="t" width="100" height="80"><button>Click</button></window>"#,
&c,
)
.expect("parse");
assert_eq!(el.children.len(), 1);
let btn = &el.children[0];
matches!(&btn.kind, NodeKind::Button { .. });
assert_eq!(btn.key, ".0");
assert_eq!(btn.children.len(), 1);
matches!(&btn.children[0].kind, NodeKind::Text { content } if content == "Click");
}
#[test]
fn h1_heading() {
let c = Empty;
let el = light_fw::runtime::parse_template(
r#"<window title="t" width="100" height="80"><h1>Title</h1></window>"#,
&c,
)
.expect("parse");
assert_eq!(el.children.len(), 1);
let h1 = &el.children[0];
assert_eq!(h1.kind, NodeKind::Column);
assert_eq!(h1.children.len(), 1);
matches!(&h1.children[0].kind, NodeKind::Text { content } if content == "Title");
}
#[test]
fn generated_key_from_index() {
let c = Empty;
let el = light_fw::runtime::parse_template(
r#"<window title="t" width="100" height="80">
<div>a</div>
<div>b</div>
</window>"#,
&c,
)
.expect("parse");
assert_eq!(el.children[0].key, ".0");
assert_eq!(el.children[1].key, ".1");
}
#[test]
fn nested_key_inheritance() {
let c = Empty;
let el = light_fw::runtime::parse_template(
r#"<window title="t" width="100" height="80">
<div id="outer">
<div id="inner">x</div>
</div>
</window>"#,
&c,
)
.expect("parse");
let outer = &el.children[0];
assert_eq!(outer.key, ".0");
let inner = &outer.children[0];
assert_eq!(inner.key, ".0.0");
}
#[test]
fn strict_rejects_unknown_event_directive() {
let c = Empty;
let result = light_fw::runtime::parse_template(
r#"<window title="t" width="100" height="80"><div @focus="h">D</div></window>"#,
&c,
);
assert!(result.is_none());
}
#[test]
fn strict_rejects_unknown_v_directive() {
let c = Empty;
let result = light_fw::runtime::parse_template(
r#"<window title="t" width="100" height="80"><div v-custom="x">D</div></window>"#,
&c,
);
assert!(result.is_none());
}
#[test]
fn strict_rejects_v_if() {
let c = Empty;
let result = light_fw::runtime::parse_template(
r#"<window title="t" width="100" height="80"><div v-if="x">D</div></window>"#,
&c,
);
assert!(result.is_none());
}
#[test]
fn text_without_model_gives_empty_textfield() {
let c = Empty;
let el = light_fw::runtime::parse_template(
r#"<window title="t" width="100" height="80"><text placeholder="Enter"></text></window>"#,
&c,
)
.expect("parse");
match &el.children[0].kind {
NodeKind::TextField {
value, placeholder, ..
} => {
assert_eq!(value, "");
assert_eq!(placeholder, "Enter");
}
other => panic!("expected TextField, got {other:?}"),
}
}
#[test]
fn text_with_model_reads_field() {
struct HasName {
#[allow(dead_code)]
name: String,
}
impl Component for HasName {
fn render(&self) -> VElement {
VElement::container("", NodeKind::Column, Vec::new())
}
fn eval_field(&self, name: &str) -> Option<String> {
if name == "name" {
Some(self.name.clone())
} else {
None
}
}
fn as_any_mut(&mut self) -> &mut dyn Any {
self
}
}
let c = HasName {
name: String::from("World"),
};
let el = light_fw::runtime::parse_template(
r#"<window title="t" width="100" height="80"><text v-model="name"></text></window>"#,
&c,
)
.expect("parse");
match &el.children[0].kind {
NodeKind::TextField { value, .. } => assert_eq!(value, "World"),
other => panic!("expected TextField, got {other:?}"),
}
}
#[test]
fn password_is_masked() {
struct P {
#[allow(dead_code)]
pw: String,
}
impl Component for P {
fn render(&self) -> VElement {
VElement::container("", NodeKind::Column, Vec::new())
}
fn eval_field(&self, _name: &str) -> Option<String> {
None
}
fn as_any_mut(&mut self) -> &mut dyn Any {
self
}
}
let c = P { pw: String::new() };
let el = light_fw::runtime::parse_template(
r#"<window title="t" width="100" height="80"><password placeholder="pw"></password></window>"#,
&c,
)
.expect("parse");
match &el.children[0].kind {
NodeKind::TextField {
masked: true,
placeholder,
..
} => assert_eq!(placeholder, "pw"),
other => panic!("expected masked TextField, got {other:?}"),
}
}
#[test]
fn interpolation_resolves_field() {
struct Counter {
#[allow(dead_code)]
count: u32,
}
impl Component for Counter {
fn render(&self) -> VElement {
VElement::container("", NodeKind::Column, Vec::new())
}
fn eval_field(&self, name: &str) -> Option<String> {
if name == "count" {
Some(self.count.to_string())
} else {
None
}
}
fn as_any_mut(&mut self) -> &mut dyn Any {
self
}
}
let c = Counter { count: 7 };
let el = light_fw::runtime::parse_template(
r#"<window title="t" width="100" height="80"><div>{{ count }}</div></window>"#,
&c,
)
.expect("parse");
assert_eq!(el.children.len(), 1);
matches!(&el.children[0].children[0].kind, NodeKind::Text { content } if content == "7");
}
#[test]
fn interpolation_unknown_field_gives_empty() {
let c = Empty;
let result = light_fw::runtime::parse_template(
r#"<window title="t" width="100" height="80"><div>{{ missing }}</div></window>"#,
&c,
);
let el = result.expect("unknown field should not fail the whole template");
assert!(
el.children[0].children.is_empty(),
"empty interpolation text should produce no child nodes"
);
}
#[test]
fn parse_app_html_returns_some() {
struct DemoApp {
#[allow(dead_code)]
count: i64,
}
impl Component for DemoApp {
fn render(&self) -> VElement {
VElement::container("", NodeKind::Column, Vec::new())
}
fn eval_field(&self, name: &str) -> Option<String> {
if name == "count" {
Some(self.count.to_string())
} else {
None
}
}
fn as_any_mut(&mut self) -> &mut dyn Any {
self
}
}
let c = DemoApp { count: 0 };
let html = include_str!("../../../examples/devtools-demo/templates/app.html");
let el = light_fw::runtime::parse_template(html, &c).expect("app.html must parse at runtime");
assert!(
el.children.len() >= 2,
"expected titlebar + body, got {}",
el.children.len()
);
}
#[test]
#[cfg(feature = "elements-checkbox")]
fn checkbox_element() {
struct HasChecked {
#[allow(dead_code)]
checked: bool,
}
impl Component for HasChecked {
fn render(&self) -> VElement {
VElement::container("", NodeKind::Column, Vec::new())
}
fn eval_field(&self, name: &str) -> Option<String> {
if name == "checked" {
Some("false".to_owned())
} else {
None
}
}
fn as_any_mut(&mut self) -> &mut dyn Any {
self
}
}
let c = HasChecked { checked: false };
let el = light_fw::runtime::parse_template(
r#"<window title="t" width="100" height="80"><checkbox v-model="checked">On</checkbox></window>"#,
&c,
)
.expect("parse");
matches!(&el.children[0].kind, NodeKind::Checkbox { .. });
}
#[test]
#[cfg(feature = "elements-radio")]
fn radio_element() {
struct HasSel {
#[allow(dead_code)]
sel: String,
}
impl Component for HasSel {
fn render(&self) -> VElement {
VElement::container("", NodeKind::Column, Vec::new())
}
fn eval_field(&self, name: &str) -> Option<String> {
if name == "sel" {
Some(self.sel.clone())
} else {
None
}
}
fn as_any_mut(&mut self) -> &mut dyn Any {
self
}
}
let c = HasSel {
sel: String::from("a"),
};
let el = light_fw::runtime::parse_template(
r#"<window title="t" width="100" height="80"><radio v-model="sel" value="a">A</radio></window>"#,
&c,
)
.expect("parse");
matches!(&el.children[0].kind, NodeKind::Radio { .. });
}
#[test]
#[cfg(feature = "elements-select")]
fn select_element() {
struct HasOpt {
#[allow(dead_code)]
opt: String,
}
impl Component for HasOpt {
fn render(&self) -> VElement {
VElement::container("", NodeKind::Column, Vec::new())
}
fn eval_field(&self, name: &str) -> Option<String> {
if name == "opt" {
Some(self.opt.clone())
} else {
None
}
}
fn as_any_mut(&mut self) -> &mut dyn Any {
self
}
}
let c = HasOpt {
opt: String::from("1"),
};
let el = light_fw::runtime::parse_template(
r#"<window title="t" width="100" height="80">
<select v-model="opt">
<option value="1">One</option>
<option value="2">Two</option>
</select>
</window>"#,
&c,
)
.expect("parse");
match &el.children[0].kind {
NodeKind::Select { options, .. } => {
assert_eq!(options.len(), 2);
assert_eq!(options[0].label, "One");
assert_eq!(options[1].label, "Two");
}
other => panic!("expected Select, got {other:?}"),
}
}
#[test]
fn simple_click_handler_accepted() {
struct Handler {
#[allow(dead_code)]
calls: u32,
}
impl Component for Handler {
fn render(&self) -> VElement {
VElement::container("", NodeKind::Column, Vec::new())
}
fn invoke_handler(&self, handler: &str, _event: Event) -> bool {
handler == "increment"
}
fn as_any_mut(&mut self) -> &mut dyn Any {
self
}
}
let c = Handler { calls: 0 };
let el = light_fw::runtime::parse_template(
r#"<window title="t" width="100" height="80"><button @click="increment">+</button></window>"#,
&c,
)
.expect("parse");
assert_eq!(el.children.len(), 1);
assert!(c.dispatch_by_name("increment", Event::Click));
assert!(!c.dispatch_by_name("other", Event::Click));
}
#[test]
fn unknown_tag_rejected() {
let c = Empty;
let result = light_fw::runtime::parse_template(
r#"<window title="t" width="100" height="80"><video src="x">V</video></window>"#,
&c,
);
assert!(result.is_none());
}
struct CountingHandler;
impl Component for CountingHandler {
fn render(&self) -> VElement {
VElement::container("", NodeKind::Column, Vec::new())
}
fn invoke_handler(&self, handler: &str, event: Event) -> bool {
handler == "increment" && matches!(event, Event::Click)
}
fn as_any_mut(&mut self) -> &mut dyn Any {
self
}
}
#[test]
fn dispatch_by_name_rejects_mousemove() {
let c = CountingHandler;
let result = c.dispatch_by_name("increment", Event::Mousemove { x: 5.0, y: 3.0 });
assert!(
!result,
"non-Click events must not trigger @click handlers by name"
);
}
#[test]
fn dispatch_by_name_rejects_mouseenter_on_builtin() {
let c = CountingHandler;
let result = c.dispatch_by_name("close", Event::Mouseenter);
assert!(!result, "builtin 'close' must not fire on non-Click events");
}
#[test]
fn dispatch_by_name_accepts_click() {
let c = CountingHandler;
let result = c.dispatch_by_name("increment", Event::Click);
assert!(result, "Click events must trigger @click handlers by name");
}