fix tests for index is default key

Author: rmorshea

src/idom/testing.py

@@ -14,6 +14,7 @@
     Generic,
     Iterator,
     List,
+    NoReturn,
     Optional,
     Tuple,
     Type,
@@ -173,8 +174,12 @@ def __exit__(
         return None
 
 
+class LogAssertionError(AssertionError):
+    """An assertion error raised in relation to log messages."""
+
+
 @contextmanager
-def assert_idom_logged(
+def assert_idom_did_log(
     match_message: str = "",
     error_type: type[Exception] | None = None,
     match_error: str = "",
@@ -192,11 +197,13 @@ def assert_idom_logged(
     error_pattern = re.compile(match_error)
 
     try:
-        with capture_idom_logs() as handler:
+        with capture_idom_logs(use_existing=clear_matched_records) as log_records:
             yield None
-    finally:
+    except Exception:
+        raise
+    else:
         found = False
-        for record in list(handler.records):
+        for record in list(log_records):
             if (
                 # record message matches
                 message_pattern.findall(record.getMessage())
@@ -222,36 +229,79 @@ def assert_idom_logged(
             ):
                 found = True
                 if clear_matched_records:
-                    handler.records.remove(record)
+                    log_records.remove(record)
 
         if not found:  # pragma: no cover
-            conditions = []
-            if match_message:
-                conditions.append(f"log message pattern {match_message!r}")
-            if error_type:
-                conditions.append(f"exception type {error_type}")
-            if match_error:
-                conditions.append(f"error message pattern {match_error!r}")
-            raise AssertionError(
-                "Could not find a log record matching the given "
-                + " and ".join(conditions)
+            _raise_log_message_error(
+                "Could not find a log record matching the given",
+                match_message,
+                error_type,
+                match_error,
             )
 
 
 @contextmanager
-def capture_idom_logs() -> Iterator[_LogRecordCaptor]:
-    """Capture logs from IDOM"""
-    if _LOG_RECORD_CAPTOR_SINGLTON in ROOT_LOGGER.handlers:
-        # this is being handled by an outer capture context
-        yield _LOG_RECORD_CAPTOR_SINGLTON
-        return None
+def assert_idom_did_not_log(
+    match_message: str = "",
+    error_type: type[Exception] | None = None,
+    match_error: str = "",
+    clear_matched_records: bool = False,
+) -> Iterator[None]:
+    """Assert the inverse of :func:`assert_idom_did_log`"""
+    try:
+        with assert_idom_did_log(
+            match_message, error_type, match_error, clear_matched_records
+        ):
+            yield None
+    except LogAssertionError:
+        pass
+    else:
+        _raise_log_message_error(
+            "Did find a log record matching the given",
+            match_message,
+            error_type,
+            match_error,
+        )
+
+
+def _raise_log_message_error(
+    prefix: str,
+    match_message: str = "",
+    error_type: type[Exception] | None = None,
+    match_error: str = "",
+) -> NoReturn:
+    conditions = []
+    if match_message:
+        conditions.append(f"log message pattern {match_message!r}")
+    if error_type:
+        conditions.append(f"exception type {error_type}")
+    if match_error:
+        conditions.append(f"error message pattern {match_error!r}")
+    raise LogAssertionError(prefix + " " + " and ".join(conditions))
+
 
-    ROOT_LOGGER.addHandler(_LOG_RECORD_CAPTOR_SINGLTON)
+@contextmanager
+def capture_idom_logs(use_existing: bool = False) -> Iterator[list[logging.LogRecord]]:
+    """Capture logs from IDOM
+
+    Parameters:
+        use_existing:
+            If already inside an existing capture context yield the same list of logs.
+            This is useful if you need to mutate the list of logs to affect behavior in
+            the outer context.
+    """
+    if use_existing:
+        for handler in reversed(ROOT_LOGGER.handlers):
+            if isinstance(handler, _LogRecordCaptor):
+                yield handler.records
+                return None
+
+    handler = _LogRecordCaptor()
+    ROOT_LOGGER.addHandler(handler)
     try:
-        yield _LOG_RECORD_CAPTOR_SINGLTON
+        yield handler.records
     finally:
-        ROOT_LOGGER.removeHandler(_LOG_RECORD_CAPTOR_SINGLTON)
-        _LOG_RECORD_CAPTOR_SINGLTON.records = []
+        ROOT_LOGGER.removeHandler(handler)
 
 
 class _LogRecordCaptor(logging.NullHandler):

tests/test_core/test_hooks.py

@@ -6,7 +6,7 @@
 import idom
 from idom.core.dispatcher import render_json_patch
 from idom.core.hooks import LifeCycleHook
-from idom.testing import HookCatcher
+from idom.testing import HookCatcher, assert_idom_did_log
 from tests.general_utils import assert_same_items
 
 
@@ -79,89 +79,68 @@ def SimpleStatefulComponent():
         assert first_hook is h
 
 
-def test_use_state_with_constructor(driver, display, driver_wait):
+async def test_use_state_with_constructor():
     constructor_call_count = idom.Ref(0)
 
+    set_outer_state = idom.Ref()
+    set_inner_key = idom.Ref()
+    set_inner_state = idom.Ref()
+
     def make_default():
         constructor_call_count.current += 1
         return 0
 
     @idom.component
     def Outer():
-        hook = idom.hooks.current_hook()
-
-        async def on_click(event):
-            hook.schedule_render()
-
-        return idom.html.div(
-            idom.html.button(
-                {"onClick": on_click, "id": "outer"}, "update outer (rerun constructor)"
-            ),
-            Inner(),
-        )
+        state, set_outer_state.current = idom.use_state(0)
+        inner_key, set_inner_key.current = idom.use_state("first")
+        return idom.html.div(state, Inner(key=inner_key))
 
     @idom.component
     def Inner():
-        count, set_count = idom.hooks.use_state(make_default)
+        state, set_inner_state.current = idom.use_state(make_default)
+        return idom.html.div(state)
 
-        async def on_click(event):
-            set_count(count + 1)
-
-        return idom.html.div(
-            idom.html.button(
-                {"onClick": on_click, "id": "inner"},
-                "update inner with state constructor",
-            ),
-            idom.html.p({"id": "count-view"}, count),
-        )
-
-    display(Outer)
+    with idom.Layout(Outer()) as layout:
+        await layout.render()
 
-    outer = driver.find_element("id", "outer")
-    inner = driver.find_element("id", "inner")
-    count = driver.find_element("id", "count-view")
+        assert constructor_call_count.current == 1
 
-    driver_wait.until(lambda d: constructor_call_count.current == 1)
-    driver_wait.until(lambda d: count.get_attribute("innerHTML") == "0")
+        set_outer_state.current(1)
+        await layout.render()
 
-    inner.click()
+        assert constructor_call_count.current == 1
 
-    driver_wait.until(lambda d: constructor_call_count.current == 1)
-    driver_wait.until(lambda d: count.get_attribute("innerHTML") == "1")
+        set_inner_state.current(1)
+        await layout.render()
 
-    outer.click()
+        assert constructor_call_count.current == 1
 
-    driver_wait.until(lambda d: constructor_call_count.current == 2)
-    driver_wait.until(lambda d: count.get_attribute("innerHTML") == "0")
+        set_inner_key.current("second")
+        await layout.render()
 
-    inner.click()
+        assert constructor_call_count.current == 2
 
-    driver_wait.until(lambda d: constructor_call_count.current == 2)
-    driver_wait.until(lambda d: count.get_attribute("innerHTML") == "1")
 
+async def test_set_state_with_reducer_instead_of_value():
+    count = idom.Ref()
+    set_count = idom.Ref()
 
-def test_set_state_with_reducer_instead_of_value(driver, display):
     def increment(count):
         return count + 1
 
     @idom.component
     def Counter():
-        count, set_count = idom.hooks.use_state(0)
-        return idom.html.button(
-            {
-                "id": "counter",
-                "onClick": lambda event: set_count(increment),
-            },
-            f"Count: {count}",
-        )
-
-    display(Counter)
+        count.current, set_count.current = idom.hooks.use_state(0)
+        return idom.html.div(count.current)
 
-    client_counter = driver.find_element("id", "counter")
+    with idom.Layout(Counter()) as layout:
+        await layout.render()
 
-    for i in range(3):
-        assert client_counter.get_attribute("innerHTML") == f"Count: {i}"
-        client_counter.click()
+        for i in range(4):
+            assert count.current == i
+            set_count.current(increment)
+            await layout.render()
 
 
 def test_set_state_checks_identity_not_equality(driver, display, driver_wait):
@@ -356,15 +335,15 @@ def cleanup():
 
 
 async def test_use_effect_cleanup_occurs_on_will_unmount():
-    outer_component_hook = HookCatcher()
+    set_key = idom.Ref()
     component_did_render = idom.Ref(False)
     cleanup_triggered = idom.Ref(False)
     cleanup_triggered_before_next_render = idom.Ref(False)
 
     @idom.component
-    @outer_component_hook.capture
     def OuterComponent():
-        return ComponentWithEffect()
+        key, set_key.current = idom.use_state("first")
+        return ComponentWithEffect(key=key)
 
     @idom.component
     def ComponentWithEffect():
@@ -387,7 +366,7 @@ def cleanup():
 
         assert not cleanup_triggered.current
 
-        outer_component_hook.latest.schedule_render()
+        set_key.current("second")
         await layout.render()
 
         assert cleanup_triggered.current
@@ -592,13 +571,13 @@ def bad_cleanup():
     assert re.match("Post-render effect .*?", first_log_line)
 
 
-async def test_error_in_effect_pre_unmount_cleanup_is_gracefully_handled(caplog):
-    outer_component_hook = HookCatcher()
+async def test_error_in_effect_pre_unmount_cleanup_is_gracefully_handled():
+    set_key = idom.Ref()
 
     @idom.component
-    @outer_component_hook.capture
     def OuterComponent():
-        return ComponentWithEffect()
+        key, set_key.current = idom.use_state("first")
+        return ComponentWithEffect(key=key)
 
     @idom.component
     def ComponentWithEffect():
@@ -611,13 +590,14 @@ def bad_cleanup():
 
         return idom.html.div()
 
-    with idom.Layout(OuterComponent()) as layout:
-        await layout.render()
-        outer_component_hook.latest.schedule_render()
-        await layout.render()  # no error
-
-    first_log_line = next(iter(caplog.records)).msg.split("\n", 1)[0]
-    assert re.match("Pre-unmount effect .*? failed", first_log_line)
+    with assert_idom_did_log(
+        match_message=r"Pre-unmount effect .*? failed",
+        error_type=ValueError,
+    ):
+        with idom.Layout(OuterComponent()) as layout:
+            await layout.render()
+            set_key.current("second")
+            await layout.render()  # no error
 
 
 async def test_use_reducer():