346 lines
12 KiB
Python
346 lines
12 KiB
Python
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
|