Implemented testing functions

src/myfasthtml/core/matcher.py

@@ -0,0 +1,345 @@
+import re
+from dataclasses import dataclass
+
+from fastcore.basics import NotStr
+
+from myfasthtml.core.testclient import MyFT
+
+
+class Predicate:
+  def __init__(self, value):
+    self.value = value
+  
+  def validate(self, actual):
+    raise NotImplementedError
+  
+  def __str__(self):
+    return f"{self.__class__.__name__}({self.value})"
+  
+  def __eq__(self, other):
+    if not isinstance(other, Predicate):
+      return False
+    return self.value == other.value
+  
+  def __hash__(self):
+    return hash(self.value)
+
+
+class StartsWith(Predicate):
+  def __init__(self, value):
+    super().__init__(value)
+  
+  def validate(self, actual):
+    return actual.startswith(self.value)
+
+
+class Contains(Predicate):
+  def __init__(self, value):
+    super().__init__(value)
+  
+  def validate(self, actual):
+    return self.value in actual
+
+
+class DoesNotContain(Predicate):
+  def __init__(self, value):
+    super().__init__(value)
+  
+  def validate(self, actual):
+    return self.value not in actual
+
+
+@dataclass
+class DoNotCheck:
+  desc: str = None
+
+
+@dataclass
+class Empty:
+  desc: str = None
+
+
+class ErrorOutput:
+  def __init__(self, path, element, expected):
+    self.path = path
+    self.element = element
+    self.expected = expected
+    self.output = []
+    self.indent = ""
+  
+  @staticmethod
+  def _unconstruct_path_item(item):
+    if "#" in item:
+      elt_name, elt_id = item.split("#")
+      return elt_name, "id", elt_id
+    elif match := re.match(r'(\w+)\[(class|name)=([^]]+)]', item):
+      return match.groups()
+    return item, None, None
+  
+  def __str__(self):
+    self.compute()
+  
+  def compute(self):
+    # first render the path hierarchy
+    for p in self.path.split(".")[:-1]:
+      elt_name, attr_name, attr_value = self._unconstruct_path_item(p)
+      path_str = self._str_element(MyFT(elt_name, {attr_name: attr_value}), keep_open=True)
+      self._add_to_output(f"{path_str}")
+      self.indent += "  "
+    
+    # then render the element
+    if hasattr(self.expected, "tag") and hasattr(self.element, "tag"):
+      # display the tag and its attributes
+      tag_str = self._str_element(self.element, self.expected)
+      self._add_to_output(tag_str)
+      
+      # Try to show where the differences are
+      error_str = self._detect_error(self.element, self.expected)
+      if error_str:
+        self._add_to_output(error_str)
+      
+      # render the children
+      if len(self.expected.children) > 0:
+        self.indent += "  "
+        element_index = 0
+        for expected_child in self.expected.children:
+          if hasattr(expected_child, "tag"):
+            if element_index < len(self.element.children):
+              # display the child
+              element_child = self.element.children[element_index]
+              child_str = self._str_element(element_child, expected_child, keep_open=False)
+              self._add_to_output(child_str)
+              
+              # manage errors in children
+              child_error_str = self._detect_error(element_child, expected_child)
+              if child_error_str:
+                self._add_to_output(child_error_str)
+              element_index += 1
+            
+            else:
+              # When there are fewer children than expected, we display a placeholder
+              child_str = "! ** MISSING ** !"
+              self._add_to_output(child_str)
+          
+          else:
+            self._add_to_output(expected_child)
+        
+        self.indent = self.indent[:-2]
+        self._add_to_output(")")
+    else:
+      self._add_to_output(str(self.element))
+      # Try to show where the differences are
+      error_str = self._detect_error(self.element, self.expected)
+      if error_str:
+        self._add_to_output(error_str)
+  
+  def _add_to_output(self, msg):
+    self.output.append(f"{self.indent}{msg}")
+  
+  @staticmethod
+  def _str_element(element, expected=None, keep_open=None):
+    # compare to itself if no expected element is provided
+    if expected is None:
+      expected = element
+    
+    # the attributes are compared to the expected element
+    elt_attrs = {attr_name: element.attrs.get(attr_name, "** MISSING **") 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())
+    
+    #
+    tag_str = f"({element.tag} {elt_attrs_str}"
+    
+    # manage the closing tag
+    if keep_open is False:
+      tag_str += " ...)" if len(element.children) > 0 else ")"
+    elif keep_open is True:
+      tag_str += "..." if elt_attrs_str == "" else " ..."
+    else:
+      # close the tag if there are no children
+      if len(element.children) == 0:  tag_str += ")"
+    
+    return tag_str
+  
+  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}
+      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:
+        elt_attrs_error = " ".join(len(f'"{name}"="{value}"') * ("^" if name in attrs_in_error else " ")
+                                   for name, value in elt_attrs.items())
+        error_str = f" {tag_str} {elt_attrs_error}"
+        return error_str
+    else:
+      if not self._matches(element, expected):
+        return len(str(element)) * "^"
+    
+    return None
+  
+  @staticmethod
+  def _matches(element, expected):
+    if element == expected:
+      return True
+    elif isinstance(expected, Predicate):
+      return expected.validate(element)
+    else:
+      return element == expected
+
+
+class ErrorComparisonOutput:
+  def __init__(self, actual_error_output, expected_error_output):
+    self.actual_error_output = actual_error_output
+    self.expected_error_output = expected_error_output
+  
+  @staticmethod
+  def adjust(to_adjust, reference):
+    for index, ref_line in enumerate(reference):
+      if "^^" in ref_line:
+        # insert an empty line in to_adjust
+        to_adjust.insert(index, "")
+    
+    return to_adjust
+  
+  def render(self):
+    # init if needed
+    if not self.actual_error_output.output:
+      self.actual_error_output.compute()
+    if not self.expected_error_output.output:
+      self.expected_error_output.compute()
+    
+    actual = self.actual_error_output.output
+    expected = self.expected_error_output.output
+    
+    # actual = self.adjust(actual, expected) # does not seem to be needed
+    expected = self.adjust(expected, actual)
+    
+    actual_max_length = len(max(actual, key=len))
+    # expected_max_length = len(max(expected, key=len))
+    
+    output = []
+    for a, e in zip(actual, expected):
+      line = f"{a:<{actual_max_length}} | {e}".rstrip()
+      output.append(line)
+    
+    return "\n".join(output)
+
+
+def matches(actual, expected, path=""):
+  def print_path(p):
+    return f"Path  : '{p}'\n" if p else ""
+  
+  def _type(x):
+    return type(x)
+  
+  def _debug(elt):
+    return str(elt) if elt else "None"
+  
+  def _debug_compare(a, b):
+    actual_out = ErrorOutput(path, a, b)
+    expected_out = ErrorOutput(path, b, b)
+    
+    comparison_out = ErrorComparisonOutput(actual_out, expected_out)
+    return comparison_out.render()
+  
+  def _error_msg(msg, _actual=None, _expected=None):
+    if _actual is None and _expected is None:
+      debug_info = ""
+    elif _actual is None:
+      debug_info = _debug(_expected)
+    elif _expected is None:
+      debug_info = _debug(_actual)
+    else:
+      debug_info = _debug_compare(_actual, _expected)
+    
+    return f"{print_path(path)}Error : {msg}\n{debug_info}"
+  
+  def _assert_error(msg, _actual=None, _expected=None):
+    assert False, _error_msg(msg, _actual=_actual, _expected=_expected)
+  
+  def _get_current_path(elt):
+    if hasattr(elt, "tag"):
+      res = f"{elt.tag}"
+      if "id" in elt.attrs:
+        res += f"#{elt.attrs['id']}"
+      elif "name" in elt.attrs:
+        res += f"[name={elt.attrs['name']}]"
+      elif "class" in elt.attrs:
+        res += f"[class={elt.attrs['class']}]"
+      return res
+    else:
+      return elt.__class__.__name__
+  
+  if actual is not None and expected is None:
+    _assert_error("Actual is not None while expected is None", _actual=actual)
+  
+  if isinstance(expected, DoNotCheck):
+    return True
+  
+  if actual is None and expected is not None:
+    _assert_error("Actual is None while expected is ", _expected=expected)
+  
+  # set the path
+  path += "." + _get_current_path(actual) if path else _get_current_path(actual)
+  
+  assert _type(actual) == _type(expected) or (hasattr(actual, "tag") and hasattr(expected, "tag")), \
+    _error_msg("The types are different: ", _actual=actual, _expected=expected)
+  
+  if isinstance(expected, (list, tuple)):
+    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 actual_child, expected_child in zip(actual, expected):
+      assert matches(actual_child, expected_child, path=path)
+  
+  elif isinstance(expected, NotStr):
+    to_compare = actual.s.lstrip('\n').lstrip()
+    assert to_compare.startswith(expected.s), _error_msg("Notstr values are different: ",
+                                                         _actual=to_compare,
+                                                         _expected=expected.s)
+  
+  elif hasattr(expected, "tag"):
+    # validate the tags names
+    assert actual.tag == expected.tag, _error_msg("The elements are different.",
+                                                  _actual=actual.tag,
+                                                  _expected=expected.tag)
+    
+    # special case when the expected element is empty
+    if len(expected.children) > 0 and isinstance(expected.children[0], Empty):
+      assert len(actual.children) == 0, _error_msg("Actual is not empty:", _actual=actual)
+      assert len(actual.attrs) == 0, _error_msg("Actual is not empty:", _actual=actual)
+      return True
+    
+    # compare the attributes
+    for expected_attr, expected_value in expected.attrs.items():
+      assert expected_attr in actual.attrs, _error_msg(f"'{expected_attr}' is not found in Actual.",
+                                                       _actual=actual.attrs)
+      
+      if isinstance(expected_value, Predicate):
+        assert expected_value.validate(actual.attrs[expected_attr]), \
+          _error_msg(f"The condition '{expected_value}' is not satisfied.",
+                     _actual=actual,
+                     _expected=expected)
+      
+      else:
+        assert actual.attrs[expected_attr] == expected.attrs[expected_attr], \
+          _error_msg(f"The values are different for '{expected_attr}': ",
+                     _actual=actual.attrs[expected_attr],
+                     _expected=expected.attrs[expected_attr])
+    
+    # compare the children
+    if len(actual.children) < len(expected.children):
+      _assert_error("Actual is lesser than expected: ", _actual=actual, _expected=expected)
+    
+    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: ",
+                                          _actual=actual,
+                                          _expected=expected)
+  
+  return True