add testing for new interfaces

Author: rmorshea

docs/source/custom_js/package-lock.json

@@ -90,11 +90,15 @@ def __init__(
         self.target = target
 
     def __eq__(self, other: Any) -> bool:
-        for slot in self.__slots__:
-            if not slot.startswith("_"):
-                if not hasattr(other, slot):
-                    return False
-                elif not getattr(other, slot) == getattr(self, slot):
+        undefined = object()
+        for attr in (
+            "function",
+            "prevent_default",
+            "stop_propagation",
+            "target",
+        ):
+            if not attr.startswith("_"):
+                if not getattr(other, attr, undefined) == getattr(self, attr):
                     return False
         return True
 
@@ -182,7 +186,7 @@ def merge_event_handler_funcs(
 ) -> EventHandlerFunc:
     """Make one event handler function from many"""
     if not functions:
-        raise ValueError("No handler functions to merge")
+        raise ValueError("No event handler functions to merge")
     elif len(functions) == 1:
         return functions[0]
 

src/idom/core/events.py

@@ -21,7 +21,7 @@
 from typing_extensions import Protocol, runtime_checkable
 
 
-if TYPE_CHECKING:
+if TYPE_CHECKING:  # pragma: no cover
     from .vdom import VdomDict
 
 

src/idom/core/proto.py

@@ -1,5 +1,12 @@
+import pytest
+
 import idom
-from idom.core.events import EventHandler
+from idom.core.events import (
+    EventHandler,
+    merge_event_handler_funcs,
+    merge_event_handlers,
+    to_event_handler_function,
+)
 
 
 def test_event_handler_repr():
@@ -11,29 +18,128 @@ def test_event_handler_repr():
 
 
 def test_event_handler_props():
-    handler_0 = EventHandler(lambda: None)
+    handler_0 = EventHandler(lambda data: None)
     assert handler_0.stop_propagation is False
     assert handler_0.prevent_default is False
+    assert handler_0.target is None
 
-    handler_1 = EventHandler(lambda: None, prevent_default=True)
+    handler_1 = EventHandler(lambda data: None, prevent_default=True)
     assert handler_1.stop_propagation is False
     assert handler_1.prevent_default is True
+    assert handler_1.target is None
 
-    handler_2 = EventHandler(lambda: None, stop_propagation=True)
+    handler_2 = EventHandler(lambda data: None, stop_propagation=True)
     assert handler_2.stop_propagation is True
     assert handler_2.prevent_default is False
+    assert handler_2.target is None
+
+    handler_3 = EventHandler(lambda data: None, target="123")
+    assert handler_3.stop_propagation is False
+    assert handler_3.prevent_default is False
+    assert handler_3.target == "123"
+
+
+def test_event_handler_equivalence():
+    async def func(data):
+        return None
+
+    assert EventHandler(func) == EventHandler(func)
+
+    assert EventHandler(lambda data: None) != EventHandler(lambda data: None)
+
+    assert EventHandler(func, stop_propagation=True) != EventHandler(
+        func, stop_propagation=False
+    )
+
+    assert EventHandler(func, prevent_default=True) != EventHandler(
+        func, prevent_default=False
+    )
+
+    assert EventHandler(func, target="123") != EventHandler(func, target="456")
+
+
+async def test_to_event_handler_function():
+    call_args = idom.Ref(None)
+
+    async def coro(*args):
+        call_args.current = args
+
+    def func(*args):
+        call_args.current = args
+
+    await to_event_handler_function(coro, positional_args=True)([1, 2, 3])
+    assert call_args.current == (1, 2, 3)
+
+    await to_event_handler_function(func, positional_args=True)([1, 2, 3])
+    assert call_args.current == (1, 2, 3)
+
+    await to_event_handler_function(coro, positional_args=False)([1, 2, 3])
+    assert call_args.current == ([1, 2, 3],)
+
+    await to_event_handler_function(func, positional_args=False)([1, 2, 3])
+    assert call_args.current == ([1, 2, 3],)
+
+
+async def test_merge_event_handler_empty_list():
+    with pytest.raises(ValueError, match="No event handlers to merge"):
+        merge_event_handlers([])
+
+
+@pytest.mark.parametrize(
+    "kwargs_1, kwargs_2",
+    [
+        ({"stop_propagation": True}, {"stop_propagation": False}),
+        ({"prevent_default": True}, {"prevent_default": False}),
+        ({"target": "this"}, {"target": "that"}),
+    ],
+)
+async def test_merge_event_handlers_raises_on_mismatch(kwargs_1, kwargs_2):
+    def func(data):
+        return None
+
+    with pytest.raises(ValueError, match="Cannot merge handlers"):
+        merge_event_handlers(
+            [
+                EventHandler(func, **kwargs_1),
+                EventHandler(func, **kwargs_2),
+            ]
+        )
+
+
+async def test_merge_event_handlers():
+    handler = EventHandler(lambda data: None)
+    assert merge_event_handlers([handler]) is handler
+
+    calls = []
+    merged_handler = merge_event_handlers(
+        [
+            EventHandler(lambda data: calls.append("first")),
+            EventHandler(lambda data: calls.append("second")),
+        ]
+    )
+    await merged_handler.function({})
+    assert calls == ["first", "second"]
+
+
+def test_merge_event_handler_funcs_empty_list():
+    with pytest.raises(ValueError, match="No event handler functions to merge"):
+        merge_event_handler_funcs([])
 
 
-def test_to_event_handler_function():
-    assert False
+async def test_merge_event_handler_funcs():
+    calls = []
 
+    async def some_func(data):
+        calls.append("some_func")
 
-def test_merge_event_handlers():
-    assert False
+    async def some_other_func(data):
+        calls.append("some_other_func")
 
+    assert merge_event_handler_funcs([some_func]) is some_func
 
-def test_merge_event_handler_funcs():
-    assert False
+    merged_handler = merge_event_handler_funcs([some_func, some_other_func])
+    await merged_handler([])
+    assert calls == ["some_func", "some_other_func"]
 
 
 def test_can_prevent_event_default_operation(driver, display):

tests/test_core/test_events.py

@@ -79,7 +79,7 @@ def test_simple_node_construction(actual, expected):
     assert actual == expected
 
 
-def test_callable_attributes_are_cast_to_event_handlers():
+async def test_callable_attributes_are_cast_to_event_handlers():
     params_from_calls = []
 
     node = idom.vdom("div", {"onEvent": lambda *args: params_from_calls.append(args)})
@@ -90,6 +90,31 @@ def test_callable_attributes_are_cast_to_event_handlers():
     handler = event_handlers["onEvent"]
     assert event_handlers == {"onEvent": EventHandler(handler.function)}
 
+    await handler.function([1, 2])
+    await handler.function([3, 4, 5])
+    assert params_from_calls == [(1, 2), (3, 4, 5)]
+
+
+async def test_event_handlers_and_callable_attributes_are_automatically_merged():
+    calls = []
+
+    node = idom.vdom(
+        "div",
+        {"onEvent": lambda: calls.append("callable_attr")},
+        event_handlers={
+            "onEvent": EventHandler(lambda data: calls.append("normal_event_handler"))
+        },
+    )
+
+    event_handlers = node.pop("eventHandlers")
+    assert node == {"tagName": "div"}
+
+    handler = event_handlers["onEvent"]
+    assert event_handlers == {"onEvent": EventHandler(handler.function)}
+
+    await handler.function([])
+    assert calls == ["normal_event_handler", "callable_attr"]
+
 
 def test_make_vdom_constructor():
     elmt = make_vdom_constructor("some-tag")