Added test for an earlier bugfix with nested collections

Author: togglebyte

tests/nested_collections.rs

@@ -1,4 +1,58 @@
+use anathema::component::*;
+use anathema::prelude::*;
+use anathema_backend::testing::TestBackend;
+use testutils::{char_press, BasicComp};
+
+#[derive(Debug, State)]
+struct Inner {
+    list: Value<List<u32>>,
+}
+
+impl Default for Inner {
+    fn default() -> Self {
+        Self {
+            list: List::from_iter([1]).into(),
+        }
+    }
+}
+
+#[derive(Debug, State, Default)]
+struct Outer {
+    inner: Value<Inner>,
+}
+
+type Comp<F> = BasicComp<F, Outer>;
+
+fn keypress(key: KeyEvent, state: &mut Outer, mut children: Children<'_, '_>, mut context: Context<'_, '_, Outer>) {
+    state.inner.set(Inner {
+        list: List::from_iter([2]).into(),
+    });
+}
+
 #[test]
 fn nested_collections() {
-    assert_eq!(expected, actual);
+    let tpl = "
+    for i in state.inner.list
+        text i
+    ";
+    let doc = Document::new("@index");
+
+    let mut backend = TestBackend::new((10, 3));
+
+    backend.add_event(None);
+    backend.add_event(Some(ComponentEvent::Key(char_press(' '))));
+    backend.add_event(Some(ComponentEvent::Stop));
+
+    let mut builder = Runtime::builder(doc, &backend);
+    builder
+        .component("index", tpl.to_template(), Comp::<_>::new(keypress), Outer::default())
+        .unwrap();
+
+    let res = builder.finish(|runtime| runtime.run(&mut backend));
+
+    assert!(backend.at(0, 0).is_char('2'));
+
+    if let Err(e) = res {
+        panic!("{e}");
+    }
 }

tests/hoppy.rs tests/statechange.rstests/hoppy.rs renamed to tests/statechange.rs

@@ -2,29 +2,20 @@ use anathema::component::*;
 use anathema::prelude::*;
 use anathema_backend::testing::TestBackend;
 use anathema_runtime::Error;
-use testutils::{char_press, Thing};
-
-#[derive(Debug, Default)]
-struct Comp;
-
-impl Component for Comp {
-    type Message = ();
-    type State = Thing;
-
-    fn on_key(
-        &mut self,
-        key: KeyEvent,
-        state: &mut Self::State,
-        mut children: Children<'_, '_>,
-        mut context: Context<'_, '_, Self::State>,
-    ) {
-        state.value.set(9);
-    }
+use testutils::{char_press, BasicComp, BasicState};
+
+fn keypress(
+    key: KeyEvent,
+    state: &mut BasicState,
+    mut children: Children<'_, '_>,
+    mut context: Context<'_, '_, BasicState>,
+) {
+    state.number.set(9);
 }
 
 #[test]
-fn lol() {
-    let tpl = "text state.value";
+fn state_change() {
+    let tpl = "text state.number";
     let doc = Document::new("@index");
 
     let mut backend = TestBackend::new((10, 3));
@@ -34,7 +25,14 @@ fn lol() {
     backend.add_event(Some(ComponentEvent::Stop));
 
     let mut builder = Runtime::builder(doc, &backend);
-    builder.from_default::<Comp>("index", tpl.to_template()).unwrap();
+    builder
+        .component(
+            "index",
+            tpl.to_template(),
+            BasicComp::<_, BasicState>::new(keypress),
+            BasicState::default(),
+        )
+        .unwrap();
 
     let res = builder.finish(|runtime| runtime.run(&mut backend));
 

testutils/src/lib.rs

@@ -1,9 +1,37 @@
-use anathema::prelude::*;
+use std::marker::PhantomData;
 use anathema::component::*;
+use anathema::prelude::*;
 
 #[derive(Debug, State, Default)]
-pub struct Thing {
-    pub value: Value<u32>,
+pub struct BasicState {
+    pub number: Value<u32>,
+}
+
+pub struct BasicComp<F, T>(F, PhantomData<T>);
+
+impl<F, T> BasicComp<F, T> {
+    pub fn new(f: F) -> Self {
+        Self(f, PhantomData)
+    }
+}
+
+impl<F, T> Component for BasicComp<F, T>
+where
+    F: FnMut(KeyEvent, &mut T, Children<'_, '_>, Context<'_, '_, T>) + 'static,
+    T: State
+{
+    type Message = ();
+    type State = T;
+
+    fn on_key(
+        &mut self,
+        key: KeyEvent,
+        state: &mut Self::State,
+        mut children: Children<'_, '_>,
+        mut context: Context<'_, '_, Self::State>,
+    ) {
+        self.0(key, state, children, context);
+    }
 }
 
 pub fn char_press(c: char) -> KeyEvent {