v1.3.5

2026-08-02 18:57:40 +02:00
parent 5e5ab8681a
commit 6fa59321c0
5759 changed files with 712133 additions and 66 deletions
@@ -0,0 +1,170 @@
+########################################################################
+# File name: xmltestutils.py
+# This file is part of: aioxmpp
+#
+# LICENSE
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as
+# published by the Free Software Foundation, either version 3 of the
+# License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this program.  If not, see
+# <http://www.gnu.org/licenses/>.
+#
+########################################################################
+import unittest
+
+
+def element_path(el, upto=None):
+    segments = []
+    parent = el.getparent()
+
+    while parent != upto:
+        similar = list(parent.iterchildren(el.tag))
+        index = similar.index(el)
+        segments.insert(0, (el.tag, index))
+        el = parent
+        parent = el.getparent()
+
+    base = "/" + el.tag
+    if segments:
+        return base + "/" + "/".join(
+            "{}[{}]".format(tag, index)
+            for tag, index in segments
+        )
+    return base
+
+
+class XMLTestCase(unittest.TestCase):
+    def assertChildrenEqual(self, tree1, tree2,
+                            strict_ordering=False,
+                            ignore_surplus_children=False,
+                            ignore_surplus_attr=False):
+        if not strict_ordering:
+            t1_childmap = {}
+            for child in tree1:
+                t1_childmap.setdefault(child.tag, []).append(child)
+            t2_childmap = {}
+            for child in tree2:
+                t2_childmap.setdefault(child.tag, []).append(child)
+
+            t1_childtags = frozenset(t1_childmap)
+            t2_childtags = frozenset(t2_childmap)
+
+            if not ignore_surplus_children or (t1_childtags - t2_childtags):
+                self.assertSetEqual(
+                    t1_childtags,
+                    t2_childtags,
+                    "Child tag occurrence differences at {}".format(
+                        element_path(tree2)))
+
+            for tag, t1_children in t1_childmap.items():
+                t2_children = t2_childmap.get(tag, [])
+                self.assertLessEqual(
+                    len(t1_children),
+                    len(t2_children),
+                    "Surplus child at {}".format(element_path(tree2))
+                )
+                if not ignore_surplus_children:
+                    self.assertGreaterEqual(
+                        len(t1_children),
+                        len(t2_children),
+                        "Surplus child at {}".format(element_path(tree2))
+                    )
+
+                for c1, c2 in zip(t1_children, t2_children):
+                    self.assertSubtreeEqual(
+                        c1, c2,
+                        ignore_surplus_attr=ignore_surplus_attr,
+                        ignore_surplus_children=ignore_surplus_children,
+                        strict_ordering=strict_ordering)
+        else:
+            t1_children = list(tree1)
+            t2_children = list(tree2)
+            self.assertLessEqual(
+                len(t1_children),
+                len(t2_children),
+                "Surplus child at {}".format(element_path(tree2))
+            )
+            if not ignore_surplus_children:
+                self.assertGreaterEqual(
+                    len(t1_children),
+                    len(t2_children),
+                    "Surplus child at {}".format(element_path(tree2))
+                )
+
+            for c1, c2 in zip(t1_children, t2_children):
+                self.assertSubtreeEqual(
+                    c1, c2,
+                    ignore_surplus_attr=ignore_surplus_attr,
+                    ignore_surplus_children=ignore_surplus_children,
+                    strict_ordering=strict_ordering)
+
+    def assertAttributesEqual(self, el1, el2,
+                              ignore_surplus_attr=False):
+        t1_attrdict = el1.attrib
+        t2_attrdict = el2.attrib
+        t1_attrs = set(t1_attrdict)
+        t2_attrs = set(t2_attrdict)
+
+        if not ignore_surplus_attr or (t1_attrs - t2_attrs):
+            self.assertSetEqual(
+                t1_attrs,
+                t2_attrs,
+                "Attribute key differences at {}".format(element_path(el2))
+            )
+
+        for attr in t1_attrs:
+            self.assertEqual(
+                t1_attrdict[attr],
+                t2_attrdict[attr],
+                "Attribute value difference at {}@{}".format(
+                    element_path(el2),
+                    attr))
+
+    def _collect_text_parts(self, el):
+        parts = [el.text or ""]
+        parts.extend(child.tail or "" for child in el)
+        return parts
+
+    def assertTextContentEqual(self, el1, el2, join_text_parts=True):
+        parts1 = self._collect_text_parts(el1)
+        parts2 = self._collect_text_parts(el2)
+        if join_text_parts:
+            self.assertEqual(
+                "".join(parts1),
+                "".join(parts2),
+                "text mismatch at {}".format(element_path(el2))
+            )
+        else:
+            self.assertSequenceEqual(
+                parts1,
+                parts2,
+                "text mismatch at {}".format(element_path(el2))
+            )
+
+    def assertSubtreeEqual(self, tree1, tree2,
+                           ignore_surplus_attr=False,
+                           ignore_surplus_children=False,
+                           strict_ordering=False,
+                           join_text_parts=True):
+        self.assertEqual(tree1.tag, tree2.tag,
+                         "tag mismatch at {}".format(element_path(tree2)))
+
+        self.assertTextContentEqual(tree1, tree2,
+                                    join_text_parts=join_text_parts)
+
+        self.assertAttributesEqual(tree1, tree2,
+                                   ignore_surplus_attr=ignore_surplus_attr)
+        self.assertChildrenEqual(
+            tree1, tree2,
+            ignore_surplus_children=ignore_surplus_children,
+            ignore_surplus_attr=ignore_surplus_attr,
+            strict_ordering=strict_ordering)