test for logged errors in layout

as a result of this additional check, we found what seemed to be
an unnecessary assertion about old component state havint the
same key and index. we change the assertion to only check for the
same key since only the key is meaningful for identity

Author: rmorshea

src/idom/core/_fixed_jsonpatch.py

@@ -9,36 +9,28 @@
 from jsonpatch import _ST_REMOVE
 from jsonpatch import DiffBuilder as _DiffBuilder
 from jsonpatch import JsonPatch as _JsonPatch
-from jsonpatch import JsonPointer, RemoveOperation, _path_join
+from jsonpatch import RemoveOperation, _path_join
 
 
-def apply_patch(doc, patch, in_place=False, pointer_cls=JsonPointer):
+def apply_patch(doc, patch, in_place=False):
     if isinstance(patch, (str, bytes)):
-        patch = JsonPatch.from_string(patch, pointer_cls=pointer_cls)
+        patch = JsonPatch.from_string(patch)
     else:
-        patch = JsonPatch(patch, pointer_cls=pointer_cls)
+        patch = JsonPatch(patch)
     return patch.apply(doc, in_place)
 
 
-def make_patch(src, dst, pointer_cls=JsonPointer):
-    return JsonPatch.from_diff(src, dst, pointer_cls=pointer_cls)
+def make_patch(src, dst):
+    return JsonPatch.from_diff(src, dst)
 
 
 class JsonPatch(_JsonPatch):
     @classmethod
-    def from_diff(
-        cls,
-        src,
-        dst,
-        optimization=True,
-        dumps=None,
-        pointer_cls=JsonPointer,
-    ):
-        json_dumper = dumps or cls.json_dumper
-        builder = DiffBuilder(src, dst, json_dumper, pointer_cls=pointer_cls)
+    def from_diff(cls, src, dst, optimization=True):
+        builder = DiffBuilder()
         builder._compare_values("", None, src, dst)
         ops = list(builder.execute())
-        return cls(ops, pointer_cls=pointer_cls)
+        return cls(ops)
 
 
 class DiffBuilder(_DiffBuilder):
@@ -47,8 +39,7 @@ def _item_removed(self, path, key, item):
             {
                 "op": "remove",
                 "path": _path_join(path, key),
-            },
-            pointer_cls=self.pointer_cls,
+            }
         )
         new_index = self.insert(new_op)
         self.store_index(item, new_index, _ST_REMOVE)

src/idom/core/layout.py

@@ -217,10 +217,9 @@ def _render_component(
         else:
             key, index = new_state.key, new_state.index
             if old_state is not None:
-                assert (key, index) == (old_state.key, old_state.index,), (
+                assert key == old_state.key, (
                     "state mismatch during component update - "
-                    f"key {key!r}!={old_state.key} "
-                    f"or index {index}!={old_state.index}"
+                    f"key {key!r}!={old_state.key!r} "
                 )
             parent.children_by_key[key] = new_state
             # need to do insertion in case where old_state is None and we're appending

src/idom/log.py

@@ -1,17 +1,12 @@
 import logging
 import sys
 from logging.config import dictConfig
-from typing import Any
 
 from .config import IDOM_DEBUG_MODE
 
 
-root_logger = logging.getLogger("idom")
-
-
-def logging_config_defaults() -> Any:
-    """Get default logging configuration"""
-    return {
+dictConfig(
+    {
         "version": 1,
         "disable_existing_loggers": False,
         "loggers": {
@@ -35,10 +30,12 @@ def logging_config_defaults() -> Any:
             }
         },
     }
+)
 
 
-dictConfig(logging_config_defaults())
+ROOT_LOGGER = logging.getLogger("idom")
+"""IDOM's root logger instance"""
 
 
 if IDOM_DEBUG_MODE.current:
-    root_logger.debug("IDOM is in debug mode")
+    ROOT_LOGGER.debug("IDOM is in debug mode")

src/idom/testing.py

@@ -1,13 +1,18 @@
+from __future__ import annotations
+
 import logging
 import re
 import shutil
+from contextlib import contextmanager
 from functools import wraps
+from traceback import format_exception
 from types import TracebackType
 from typing import (
     Any,
     Callable,
     Dict,
     Generic,
+    Iterator,
     List,
     Optional,
     Tuple,
@@ -29,6 +34,8 @@
 from idom.server.proto import ServerFactory, ServerType
 from idom.server.utils import find_available_port
 
+from .log import ROOT_LOGGER
+
 
 __all__ = [
     "find_available_port",
@@ -166,6 +173,86 @@ def __exit__(
         return None
 
 
+@contextmanager
+def assert_idom_logged(
+    match_message: str = "",
+    error_type: type[Exception] | None = None,
+    match_error: str = "",
+    clear_matched_records: bool = False,
+) -> Iterator[None]:
+    """Assert that IDOM produced a log matching the described message or error.
+
+    Args:
+        match_message: Must match a logged message.
+        error_type: Checks the type of logged exceptions.
+        match_error: Must match an error message.
+        clear_matched_records: Whether to remove logged records that match.
+    """
+    message_pattern = re.compile(match_message)
+    error_pattern = re.compile(match_error)
+
+    try:
+        with capture_idom_logs() as handler:
+            yield None
+    finally:
+        found = False
+        for record in list(handler.records):
+            if (
+                # record message matches
+                message_pattern.findall(record.getMessage())
+                # error type matches
+                and (
+                    not error_type
+                    or (
+                        record.exc_info is not None
+                        and issubclass(record.exc_info[0], error_type)
+                    )
+                )
+                # error message pattern matches
+                and (
+                    not match_error
+                    or (
+                        record.exc_info is not None
+                        and error_pattern.findall(
+                            "".join(format_exception(*record.exc_info))
+                        )
+                    )
+                )
+            ):
+                found = True
+                if clear_matched_records:
+                    handler.records.remove(record)
+
+        if not found:
+            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)
+            )
+
+
+@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
+
+    ROOT_LOGGER.addHandler(_LOG_RECORD_CAPTOR_SINGLTON)
+    try:
+        yield _LOG_RECORD_CAPTOR_SINGLTON
+    finally:
+        ROOT_LOGGER.removeHandler(_LOG_RECORD_CAPTOR_SINGLTON)
+        _LOG_RECORD_CAPTOR_SINGLTON.records = []
+
+
 class _LogRecordCaptor(logging.NullHandler):
     def __init__(self) -> None:
         self.records: List[logging.LogRecord] = []
@@ -176,6 +263,9 @@ def handle(self, record: logging.LogRecord) -> bool:
         return True
 
 
+_LOG_RECORD_CAPTOR_SINGLTON = _LogRecordCaptor()
+
+
 class HookCatcher:
     """Utility for capturing a LifeCycleHook from a component