Added TreeView and Panel

src/myfasthtml/test/matcher.py

@@ -6,6 +6,8 @@ from fastcore.basics import NotStr
 from myfasthtml.core.utils import quoted_str
 from myfasthtml.test.testclient import MyFT
 
+MISSING_ATTR = "** MISSING **"
+
 
 class Predicate:
   def __init__(self, value):
@@ -114,6 +116,18 @@ class AttributeForbidden(ChildrenPredicate):
     return element
 
 
+class TestObject:
+  def __init__(self, cls, **kwargs):
+    self.cls = cls
+    self.attrs = kwargs
+
+
+class TestCommand(TestObject):
+  def __init__(self, name, **kwargs):
+    super().__init__("Command", **kwargs)
+    self.attrs = {"name": name} | kwargs  # name should be first
+
+
 @dataclass
 class DoNotCheck:
   desc: str = None
@@ -187,6 +201,16 @@ class ErrorOutput:
         
         self.indent = self.indent[:-2]
         self._add_to_output(")")
+    
+    elif isinstance(self.expected, TestObject):
+      cls = _mytype(self.element)
+      attrs = {attr_name: _mygetattr(self.element, attr_name) for attr_name in self.expected.attrs}
+      self._add_to_output(f"({cls} {_str_attrs(attrs)})")
+      # Try to show where the differences are
+      error_str = self._detect_error_2(self.element, self.expected)
+      if error_str:
+        self._add_to_output(error_str)
+    
     else:
       self._add_to_output(str(self.element))
       # Try to show where the differences are
@@ -205,7 +229,7 @@ class ErrorOutput:
     
     if hasattr(element, "tag"):
       # the attributes are compared to the expected element
-      elt_attrs = {attr_name: element.attrs.get(attr_name, "** MISSING **") for attr_name in
+      elt_attrs = {attr_name: element.attrs.get(attr_name, MISSING_ATTR) for attr_name in
                    [attr_name for attr_name in expected.attrs if attr_name is not None]}
       
       elt_attrs_str = " ".join(f'"{attr_name}"="{attr_value}"' for attr_name, attr_value in elt_attrs.items())
@@ -228,7 +252,7 @@ class ErrorOutput:
   def _detect_error(self, element, expected):
     if hasattr(expected, "tag") and hasattr(element, "tag"):
       tag_str = len(element.tag) * (" " if element.tag == expected.tag else "^")
-      elt_attrs = {attr_name: element.attrs.get(attr_name, "** MISSING **") for attr_name in expected.attrs}
+      elt_attrs = {attr_name: element.attrs.get(attr_name, MISSING_ATTR) for attr_name in expected.attrs}
       attrs_in_error = [attr_name for attr_name, attr_value in elt_attrs.items() if
                         not self._matches(attr_value, expected.attrs[attr_name])]
       if attrs_in_error:
@@ -242,6 +266,35 @@ class ErrorOutput:
     
     return None
   
+  def _detect_error_2(self, element, expected):
+    """
+    Too lazy to refactor original _detect_error
+    :param element:
+    :param expected:
+    :return:
+    """
+    if hasattr(expected, "tag") or isinstance(expected, TestObject):
+      element_cls = _mytype(element)
+      expected_cls = _mytype(expected)
+      str_tag_error = (" " if self._matches(element_cls, expected_cls) else "^") * len(element_cls)
+      
+      element_attrs = {attr_name: _mygetattr(element, attr_name) for attr_name in expected.attrs}
+      expected_attrs = {attr_name: _mygetattr(expected, attr_name) for attr_name in expected.attrs}
+      attrs_in_error = {attr_name for attr_name, attr_value in element_attrs.items() if
+                        not self._matches(attr_value, expected_attrs[attr_name])}
+      str_attrs_error = " ".join(len(f'"{name}"="{value}"') * ("^" if name in attrs_in_error else " ")
+                                 for name, value in element_attrs.items())
+      if str_attrs_error.strip() or str_tag_error.strip():
+        return f" {str_tag_error} {str_attrs_error}"
+      else:
+        return None
+    
+    else:
+      if not self._matches(element, expected):
+        return len(str(element)) * "^"
+    
+    return None
+  
   @staticmethod
   def _matches(element, expected):
     if element == expected:
@@ -347,6 +400,34 @@ def matches(actual, expected, path=""):
   # set the path
   path += "." + _get_current_path(actual) if path else _get_current_path(actual)
   
+  if isinstance(expected, TestObject):
+    assert _mytype(actual) == _mytype(expected), _error_msg("The types are different: ",
+                                                            _actual=actual,
+                                                            _expected=expected)
+    
+    for attr, value in expected.attrs.items():
+      assert hasattr(actual, attr), _error_msg(f"'{attr}' is not found in Actual.",
+                                               _actual=actual,
+                                               _expected=expected)
+      try:
+        matches(getattr(actual, attr), value)
+      except AssertionError as e:
+        match = re.search(r"Error : (.+?)\n", str(e))
+        if match:
+          assert False, _error_msg(f"{match.group(1)} for '{attr}':",
+                                   _actual=getattr(actual, attr),
+                                   _expected=value)
+        assert False, _error_msg(f"The values are different for '{attr}': ",
+                                 _actual=getattr(actual, attr),
+                                 _expected=value)
+    return True
+  
+  if isinstance(expected, Predicate):
+    assert expected.validate(actual), \
+      _error_msg(f"The condition '{expected}' is not satisfied.",
+                 _actual=actual,
+                 _expected=expected)
+  
   assert _type(actual) == _type(expected) or (hasattr(actual, "tag") and hasattr(expected, "tag")), \
     _error_msg("The types are different: ", _actual=actual, _expected=expected)
   
@@ -359,6 +440,14 @@ def matches(actual, expected, path=""):
     for actual_child, expected_child in zip(actual, expected):
       assert matches(actual_child, expected_child, path=path)
   
+  elif isinstance(expected, dict):
+    if len(actual) < len(expected):
+      _assert_error("Actual is smaller than expected: ", _actual=actual, _expected=expected)
+    if len(actual) > len(expected):
+      _assert_error("Actual is bigger than expected: ", _actual=actual, _expected=expected)
+    for k, v in expected.items():
+      assert matches(actual[k], v, path=f"{path}[{k}={v}]")
+  
   elif isinstance(expected, NotStr):
     to_compare = actual.s.lstrip('\n').lstrip()
     assert to_compare.startswith(expected.s), _error_msg("Notstr values are different: ",
@@ -404,8 +493,9 @@ def matches(actual, expected, path=""):
     for actual_child, expected_child in zip(actual.children, expected_children):
       assert matches(actual_child, expected_child, path=path)
   
+  
   else:
-    assert actual == expected, _error_msg("The values are different: ",
+    assert actual == expected, _error_msg("The values are different",
                                           _actual=actual,
                                           _expected=expected)
   
@@ -466,3 +556,25 @@ def find(ft, expected):
     raise AssertionError(f"No element found for '{expected}'")
   
   return res
+
+
+def _mytype(x):
+  if hasattr(x, "tag"):
+    return x.tag
+  if isinstance(x, TestObject):
+    return x.cls.__name__ if isinstance(x.cls, type) else str(x.cls)
+  return type(x).__name__
+
+
+def _mygetattr(x, attr):
+  if hasattr(x, "attrs"):
+    return x.attrs.get(attr, MISSING_ATTR)
+  
+  if not hasattr(x, attr):
+    return MISSING_ATTR
+  
+  return getattr(x, attr, MISSING_ATTR)
+
+
+def _str_attrs(attrs: dict):
+  return " ".join(f'"{attr_name}"="{attr_value}"' for attr_name, attr_value in attrs.items())