init

backend-django/backend/tests/utils/predicates.py

@@ -0,0 +1,127 @@
+from .samples import my_func, _my_private_func, MyClass
+from ...utils.predicates import func_class_name_is_in, func_class_name_is_not_in, func_name_is_in, func_name_is_not_in, func_is_public
+from django.test import SimpleTestCase
+
+
+class PredicatesTest(SimpleTestCase):
+
+    def __test_func_class_name_is_in(self, negation: bool = False):
+        """ teste func_class_name_is_in et func_class_name_is_not_in """
+
+        func = func_class_name_is_not_in if negation else func_class_name_is_in
+        result = negation is not True
+
+        own_name = self.__class__.__name__
+        MainType = MyClass
+        main_type = MainType(11)
+        main_type_name = MainType.__name__
+        SubType = MyClass.MySubClass
+        sub_type = SubType(13)
+        sub_type_name = SubType.__name__
+
+        def local_func(a: int, b: int):
+            return a + b
+
+        # fonction native : None
+        self.assertEqual(func(str.__name__)(str.join), False)
+
+        # fonction locale : None
+        self.assertEqual(func(own_name)(local_func), False)
+
+        # méthodes
+        predicate = func(main_type_name)
+        self.assertEqual(predicate(MainType.class_met), result)
+        self.assertEqual(predicate(MainType.static_met), result)
+        self.assertEqual(predicate(main_type.std_met), result)
+        self.assertEqual(predicate(SubType.sub_class_met), not result)
+        self.assertEqual(predicate(SubType.sub_static_met), not result)
+        self.assertEqual(predicate(sub_type.sub_std_met), not result)
+
+        predicate = func(sub_type_name)
+        self.assertEqual(predicate(MainType.class_met), not result)
+        self.assertEqual(predicate(MainType.static_met), not result)
+        self.assertEqual(predicate(main_type.std_met), not result)
+        self.assertEqual(predicate(SubType.sub_class_met), result)
+        self.assertEqual(predicate(SubType.sub_static_met), result)
+        self.assertEqual(predicate(sub_type.sub_std_met), result)
+
+    def __test_func_name_is_in(self, negation: bool = False):
+        """ teste func_name_is_in et func_name_is_not_in """
+
+        func = func_name_is_not_in if negation else func_name_is_in
+        result = negation is not True
+
+        MainType = MyClass
+        main_type = MainType(11)
+        SubType = MyClass.MySubClass
+        sub_type = SubType(13)
+
+        def local_func(a: int, b: int):
+            return a + b
+
+        # fonction native
+        self.assertEqual(func('join')(str.join), result)
+        self.assertEqual(func('other', 'join')(str.join), result)
+
+        # autre fonction, fonction locale
+        self.assertEqual(func('local_func')(local_func), result)
+        self.assertEqual(func('other', 'local_func')(local_func), result)
+        self.assertEqual(func('my_func')(my_func), result)
+        self.assertEqual(func('other', 'my_func')(my_func), result)
+
+
+        # méthodes
+        predicate = func('class_met', 'std_met', 'sub_static_met')
+        self.assertEqual(predicate(MainType.class_met), result)
+        self.assertEqual(predicate(MainType.static_met), not result)
+        self.assertEqual(predicate(main_type.std_met), result)
+        self.assertEqual(predicate(SubType.sub_class_met), not result)
+        self.assertEqual(predicate(SubType.sub_static_met), result)
+        self.assertEqual(predicate(sub_type.sub_std_met), not result)
+
+        predicate = func('static_met', 'sub_class_met', 'sub_std_met')
+        self.assertEqual(predicate(MainType.class_met), not result)
+        self.assertEqual(predicate(MainType.static_met), result)
+        self.assertEqual(predicate(main_type.std_met), not result)
+        self.assertEqual(predicate(SubType.sub_class_met), result)
+        self.assertEqual(predicate(SubType.sub_static_met), not result)
+        self.assertEqual(predicate(sub_type.sub_std_met), result)
+
+
+    def test_func_class_name_is_in(self):
+        self.__test_func_class_name_is_in()
+
+    def test_func_class_name_is_not_in(self):
+        self.__test_func_class_name_is_in(negation=True)
+
+    def test_func_name_is_in(self):
+        self.__test_func_name_is_in()
+
+    def test_func_name_is_not_in(self):
+        self.__test_func_name_is_in(negation=True)
+
+    def test_func_is_public(self):
+        MainType = MyClass
+        main_type = MainType(11)
+        SubType = MyClass.MySubClass
+        sub_type = SubType(13)
+
+        def local_func(a: int, b: int):
+            return a + b
+
+        # fonction native
+        self.assertEqual(func_is_public(str.join), True)
+
+        # autre fonction, fonction locale
+        self.assertEqual(func_is_public(local_func), True)
+        self.assertEqual(func_is_public(my_func), True)
+        self.assertEqual(func_is_public(_my_private_func), False)
+
+        # méthodes
+        self.assertEqual(func_is_public(MainType._protected_met), False)
+        self.assertEqual(func_is_public(MainType.class_met), True)
+        self.assertEqual(func_is_public(MainType.static_met), True)
+        self.assertEqual(func_is_public(main_type.std_met), True)
+        self.assertEqual(func_is_public(SubType.sub_class_met), True)
+        self.assertEqual(func_is_public(SubType.sub_static_met), True)
+        self.assertEqual(func_is_public(sub_type.sub_std_met), True)