Merge pull request #79 from mitchmindtree/nested-push-eval

feat: Add a test for nested push eval. Ignored until #78 is solved.

Author: mitchmindtree

crates/gantz_core/tests/nested.rs

@@ -24,6 +24,17 @@ fn node_assert_eq() -> node::Expr {
     node::expr("(begin (assert! (equal? $l $r)))").unwrap()
 }
 
+fn node_number() -> node::Expr {
+    node::expr(
+        "
+        (let ((x $x))
+          (set! state (if (number? x) x state))
+          state)
+    ",
+    )
+    .unwrap()
+}
+
 // Helper trait for debugging the graph.
 trait DebugNode: Debug + Node {}
 impl<T> DebugNode for T where T: Debug + Node {}
@@ -169,16 +180,6 @@ fn test_graph_nested_counter() {
     )
     .unwrap();
 
-    // The number node for receiving the result.
-    let number = node::expr(
-        "
-        (let ((x $x))
-          (set! state (if (number? x) x state))
-          state)
-    ",
-    )
-    .unwrap();
-
     // Graph A.
     let mut ga = GraphNode::default();
     let inlet = ga.add_node(Box::new(node::graph::Inlet) as Box<dyn DebugNode>);
@@ -191,11 +192,11 @@ fn test_graph_nested_counter() {
     let mut gb = petgraph::graph::DiGraph::new();
     let push = gb.add_node(Box::new(node_push()) as Box<dyn DebugNode>);
     let graph_a = gb.add_node(Box::new(ga) as Box<_>);
-    let number = gb.add_node(Box::new(number) as Box<_>);
+    let number = gb.add_node(Box::new(node_number()) as Box<_>);
     gb.add_edge(push, graph_a, Edge::from((0, 0)));
     gb.add_edge(graph_a, number, Edge::from((0, 0)));
 
-    // Generate the module, which should have just one top-level expr for `push`.
+    // Generate the module.
     let module = gantz_core::codegen::module(&gb);
 
     // Create the VM.
@@ -211,8 +212,8 @@ fn test_graph_nested_counter() {
         vm.run(f.to_pretty(100)).unwrap();
     }
 
-    // Increment the nested counter by pushing evaluation. The first is `0`, the
-    // second is `1`.
+    // Increment the nested counter by pushing evaluation.
+    // The first is `0`, the second is `1`.
     vm.call_function_by_name_with_args(&push_eval_fn_name(&[push.index()]), vec![])
         .unwrap();
     vm.call_function_by_name_with_args(&push_eval_fn_name(&[push.index()]), vec![])
@@ -236,3 +237,82 @@ fn test_graph_nested_counter() {
         .expect("number state was `None`");
     assert_eq!(number_state, 1);
 }
+
+// A simple test for pushing evaluation from a node within a nested graph.
+//
+// GRAPH A
+//
+//    --------
+//    | Push |
+//    -+------
+//     |
+//    -+----
+//    | 42 |
+//    -+----
+//     |
+//    -+--------
+//    | Outlet |
+//    ----------
+//
+// GRAPH B
+//
+//    -+---------
+//    | GRAPH A |
+//    -+---------
+//     |
+//    -+--------
+//    | number |
+//    ----------
+//
+// A simple-as-possible demonstration of pushing evaluation from within a nested
+// node, and propagating that evaluation through the outlets of the graph node.
+#[test]
+#[ignore = "requires #78, #77"]
+fn test_graph_nested_push_eval() {
+    // GRAPH A
+    let mut ga = GraphNode::default();
+    let push = ga.add_node(Box::new(node_push()) as Box<dyn DebugNode>);
+    let int = ga.add_node(Box::new(node_int(42)) as Box<_>);
+    let outlet = ga.add_node(Box::new(node::graph::Outlet) as Box<_>);
+    ga.add_edge(push, int, Edge::from((0, 0)));
+    ga.add_edge(int, outlet, Edge::from((0, 0)));
+
+    // Graph B.
+    let mut gb = petgraph::graph::DiGraph::new();
+    let graph_a = gb.add_node(Box::new(ga) as Box<dyn DebugNode>);
+    let number = gb.add_node(Box::new(node_number()) as Box<_>);
+    gb.add_edge(graph_a, number, Edge::from((0, 0)));
+
+    // Generate the module.
+    let module = gantz_core::codegen::module(&gb);
+
+    // Create the VM.
+    let mut vm = Engine::new_base();
+
+    // Initialise the node state vars.
+    vm.register_value(ROOT_STATE, SteelVal::empty_hashmap());
+    gantz_core::graph::register(&gb, &[], &mut vm);
+
+    // Register the fns.
+    for f in module {
+        println!("{}\n", f.to_pretty(100));
+        vm.run(f.to_pretty(100)).unwrap();
+    }
+
+    // Call the nested push node's eval fn.
+    let push_path = [graph_a.index(), push.index()];
+    vm.call_function_by_name_with_args(&push_eval_fn_name(&push_path), vec![])
+        .unwrap();
+
+    // Now check that the outlet's state is `42`.
+    let outlet_state = node::state::extract::<u32>(&vm, &[graph_a.index(), outlet.index()])
+        .expect("failed to extract outlet state")
+        .expect("outlet state was `None`");
+    assert_eq!(outlet_state, 42);
+
+    // Check that the number in the root graph was updated from the outlet.
+    let number_state = node::state::extract::<u32>(&vm, &[number.index()])
+        .expect("failed to extract number state")
+        .expect("number state was `None`");
+    assert_eq!(number_state, 42);
+}