Initial commit

Author: RootLUG

LICENSE.txt

@@ -0,0 +1,37 @@
+fassert: Fuzzy assert
+---------------------
+
+Assert in your tests only a subset of data that matters
+
+```
+from fassert import fassert
+
+# Usage: fassert(<data>, <template>)
+
+fassert("This is expected", "This is expected")
+
+fassert("This matches as well", re.compile(r"[thismachewl ]+", re.I))
+
+fassert(
+    {"key": "value", "key2": "value2"},
+    {"key": "value"}
+) # key2: value2 is ignored as it's not defined in the template
+
+fassert(
+    {"key": "value"},
+    # You can nest and combine the fuzzy matching types in containers
+    {re.compile(r"[a-z]{3}"): "value"}
+)
+
+# Template can contain callables as well
+fassert("value", lambda x: x == "value")
+
+try:
+    fassert({"a": "b"}, {"c": "d"})  # This will fail, {"c":"d"} is not in the target data
+except AssertionError:
+    pass  # All the examples within the try block above will raise this exception
+```
+
+In fassert, you can define a template to match your data against.
+When you use a type that is a container (e.g. list, tuple, dict, etc...), then only the data that you defined in the template will be asserted.
+All the addition data in the container will be ignored

README.md

@@ -0,0 +1,103 @@
+import inspect
+from abc import ABC, abstractmethod
+from typing import Pattern, Sequence, Literal
+
+
+class FuzzyAssert:
+    def __init__(self):
+        self.eval_functions = True
+        self.regex_allowed = True
+        self.check_minimum_sequence_length = True
+        self.fuzzy_sequence_types = False
+
+    def match(self, data, template) -> Literal[True]:
+        """
+        Attempt to match the template onto the data.
+        Each item in a `template` must have a match in the `data`.
+        Extra items/data inside the `data` (if it is a container type) is ignored.
+
+        :param data: Data to match against, extra data, container types or other python types is ignored
+        :param template: Template to match against, everything defined here must have a match
+        :return: True if `template` matches the `data`
+        """
+        if inspect.isfunction(template):
+            if self.eval_functions and template(data):
+                return True
+            raise AssertionError("Template function does not match the data")
+        elif self.regex_allowed and type(data) == str and isinstance(template, Pattern):
+            if not template.match(data):
+                raise AssertionError(
+                    "Template regex `{}` does not match the data".format(repr(template))
+                )
+            else:
+                return True
+        # This must be before generic test of Sequence types because str/bytes are also considered as sequences
+        elif isinstance(data, (str, bytes)) and isinstance(template, (str, bytes)):
+            if data == template:
+                return True
+            else:
+                raise AssertionError("Template does not match the data")
+        elif isinstance(data, Sequence) and isinstance(template, Sequence) and (
+                self.fuzzy_sequence_types or (type(data) == type(template))
+        ):
+            if self.check_minimum_sequence_length and len(template) > len(data):
+                raise AssertionError(
+                    "Template sequence length is higher then the length of the data: `{}`".format(
+                        template
+                    )
+                )
+            elif len(template) == 0:
+                return True
+
+            for template_item in template:
+                for data_item in data:
+                    try:
+                        self.match(data_item, template_item)
+                        break
+                    except AssertionError:
+                        continue
+                else:
+                    raise AssertionError(
+                        "Sequence item from the `template` not found inside the `data`: `{}`".format(
+                            template_item
+                        )
+                    )
+            return True
+
+        if type(data) != type(template):
+            raise AssertionError(f"Template type `{type(template)}` does not match the type of data `{type(data)}`")
+        elif isinstance(data, dict):
+            for template_key, template_value in template.items():
+                for data_key, data_value in data.items():
+                    try:
+                        self.match(data_key, template_key)
+                        self.match(data_value, template_value)
+                        break
+                    except AssertionError:
+                        continue
+                else:
+                    raise AssertionError(
+                        "Could not find a matching key/value for dictionary item `{}`:`{}`".format(
+                            repr(template_key), repr(template_value)
+                        )
+                    )
+            return True
+        else:
+            if data == template:
+                return True
+            else:
+                raise AssertionError(
+                    "Target data does not match the template: `{}`".format(
+                        repr(template)
+                    )
+                )
+
+
+class FassertInterface(ABC):
+    @abstractmethod
+    def __fassert__(self, other, matcher: FuzzyAssert) -> bool:
+        ...
+
+
+def fassert(data, template) -> bool:
+    return FuzzyAssert().match(data, template)

fassert/__init__.py

@@ -0,0 +1,3 @@
+[build-system]
+requires = ["setuptools>=42"]
+build-backend = "setuptools.build_meta"

pyproject.toml

@@ -0,0 +1,14 @@
+[metadata]
+name = fassert
+version = 0.1
+author = Martin Carnogursky
+author_email = admin@sourcecode.ai
+
+classifiers =
+    Programming Language :: Python :: 3
+    Operating System :: OS Independent
+
+
+[options]
+packages = find:
+python_requires = >=3.8

setup.cfg

@@ -0,0 +1,76 @@
+import unittest
+import re
+
+from fassert import FuzzyAssert
+
+
+class ConfigurationTest(unittest.TestCase):
+    def test_eval_function(self):
+        data = "test"
+        template = lambda x: len(x) == 4
+
+        fasserter = FuzzyAssert()
+
+        self.assertIs(fasserter.eval_functions, True)
+        fasserter.match(data, template)
+
+        fasserter.eval_functions = False
+        self.assertRaises(AssertionError, fasserter.match, data, template)
+
+    def test_fuzzy_sequence_types(self):
+        test_data = (
+            ((), []),
+            (set(), ()),
+            (set(), []),
+        )
+
+        fasserter = FuzzyAssert()
+        self.assertIs(fasserter.fuzzy_sequence_types, False)
+
+        for data, template in test_data:
+            with self.subTest(data=data, template=template):
+                self.assertRaises(AssertionError, fasserter.match, data, template)
+
+            with self.subTest(data=template, template=data):
+                self.assertRaises(AssertionError, fasserter.match, template, data)
+
+    def test_check_minimum_sequence_length(self):
+        test_data = (
+            ([""], ["", ""]),
+            (["test"], [re.compile(".{4}"), "test", re.compile("^test$")])
+        )
+
+        fasserter = FuzzyAssert()
+
+
+        for data, template in test_data:
+            with self.subTest(data=data, template=template):
+                fasserter.check_minimum_sequence_length = True
+                self.assertRaises(AssertionError, fasserter.match, data, template)
+
+                fasserter.check_minimum_sequence_length = False
+                self.assertIs(fasserter.match(data, template), True)
+
+
+    def test_regex_allowed(self):
+        test_data = (
+            ("", re.compile("")),
+            ("test", re.compile("^test$")),
+            ("test", re.compile("test")),
+            ("test", re.compile(".{4}"))
+        )
+
+        fasserter = FuzzyAssert()
+
+        for data, template in test_data:
+            with self.subTest(data=data, template=template):
+                fasserter.regex_allowed = False
+                self.assertRaises(AssertionError, fasserter.match, data, template)
+
+                fasserter.regex_allowed = True
+                self.assertIs(fasserter.match(data, template), True)
+
+            with self.subTest(data=template, template=data):
+                fasserter.regex_allowed = True
+                # a string would never match regex, e.g. the regex matches are one way only from template to data
+                self.assertRaises(AssertionError, fasserter.match, template, data)

tests/__init__.py

@@ -0,0 +1,33 @@
+import unittest
+
+from fassert import fassert
+
+
+class IterablesTest(unittest.TestCase):
+    def test_exact_list(self):
+        test_data = (
+            [],
+            ["a"],
+            [42],
+            ["a", 42, None],
+            (),
+            ("a",),
+            (42),
+            ("a", "42", None),
+            set(),
+            {"a"},
+            {"a", 42, None}
+        )
+        for data in test_data:
+            with self.subTest(data=data):
+                self.assertIs(fassert(data, data), True)
+
+    def test_subtest(self):
+        test_data = (
+            (["a", "b"], ["a"]),
+            (("a", "b"), ("a",)),
+            # TODO: ({"b", "a"}, {"a"})
+        )
+        for data, template in test_data:
+            with self.subTest(data=data, template=template):
+                self.assertIs(fassert(data, template), True)

tests/test_configuration.py

@@ -0,0 +1,34 @@
+import re
+import unittest
+
+
+class ReadmeTest(unittest.TestCase):
+    # Copy-paste the example code from README into this test
+    def test_readme_main_example(self):
+        from fassert import fassert
+
+
+        # Usage: fassert(<data>, <template>)
+
+        fassert("This is expected", "This is expected")
+
+        fassert("This matches as well", re.compile(r"[thismacewl ]+", re.I))
+
+        fassert(
+            {"key": "value", "key2": "value2"},
+            {"key": "value"}
+        )  # key2: value2 is ignored as it's not defined in the template
+
+        fassert(
+            {"key": "value"},
+            # You can nest and combine the fuzzy matching types in containers
+            {re.compile(r"[a-z]{3}"): "value"}
+        )
+
+        # Template can contain callables as well
+        fassert("value", lambda x: x == "value")
+
+        try:
+            fassert({"a": "b"}, {"c": "d"})  # This will fail, {"c":"d"} is not in the target data
+        except AssertionError:
+            pass  # All the examples within the try block above will raise this exception

tests/test_iterables.py

@@ -0,0 +1,61 @@
+import re
+import unittest
+
+from fassert import fassert
+
+
+class MatchingPrimitivesTest(unittest.TestCase):
+    def test_matching_primitives(self):
+        test_data = (
+            ("", ""),
+            ("test_string", "test_string"),
+            (b"test_bytes", b"test_bytes"),
+            ("", re.compile(r"^$")),
+            ("test", re.compile("[a-z]{4}")),
+            (42, 42),
+            (0, 0),
+            (42.0, 42.0),
+            (0.0, 0.0),
+            (3.14, 3.14),
+            (None, None),
+            ((), ()),
+            ([], []),
+            (set(), set()),
+            (dict(), dict()),
+        )
+
+        for data, template in test_data:
+            with self.subTest(data=data, template=template):
+                assert fassert(data, template)
+
+    def test_same_type_different_value_not_matching(self):
+        test_data = (
+            ("", "value"),
+            ("value", ""),
+            (b"", b"value"),
+            (0, 42),
+            (42, 0),
+            (1, 3),
+            (42.0, 0.0),
+            (0.0, 42.0),
+        )
+
+        for data, template in test_data:
+            with self.subTest(data=data, template=template):
+                self.assertRaises(AssertionError, fassert, data, template)
+
+
+    def test_different_types_not_matching(self):
+        test_data = (
+            ("", ()),
+            ("", []),
+            ("", set()),
+            (b"value", ""),
+        )
+
+        for data, template in test_data:
+            with self.subTest(data=data, template=template):
+                self.assertRaises(AssertionError, fassert, data, template)
+
+            with self.subTest(data=template, template=data):
+                self.assertRaises(AssertionError, fassert, template, data)