20251005

tests/__init__.py

@@ -1 +1 @@
-# anb_python_components/__init__.py
+# tests/__init__.py

tests/classes/__init__.py

@@ -0,0 +1 @@
+# tests/classes/__init__.py

tests/classes/action_state_test.py

@@ -0,0 +1,138 @@
+# action_state_test.py
+
+import unittest
+
+from anb_python_components.classes.action_state import ActionState, ActionStateMessage, MessageType
+
+class ActionStateTest(unittest.TestCase):
+    def test_init (self):
+        state = ActionState[bool](False)
+        self.assertIsInstance(state, ActionState)
+        self.assertFalse(state.value)
+        state.value = True
+        self.assertTrue(state.value)
+    
+    def test_add_message (self):
+        message = ActionStateMessage(MessageType.INFO, "Test message")
+        
+        state = ActionState[bool](False)
+        state.add_message(message)
+        
+        self.assertEqual(1, state.count())
+    
+    @staticmethod
+    def get_test_state (no_warning: bool = False, no_error: bool = False, state_value: bool = False) -> ActionState[
+        bool]:
+        """
+        Генерирует тестовое состояние.
+        :param no_warning: Без предупреждений.
+        :param no_error: Без ошибок.
+        :param state_value: Значение состояния.
+        :return: Тестовое состояние.
+        """
+        state = ActionState[bool](False)
+        
+        state.add_info("Тестовое сообщение1")
+        if not no_error:
+            state.add_error("Тестовое сообщение2")
+        state.add_info("Тестовое сообщение3")
+        state.add_info("Тестовое сообщение4")
+        if not no_warning:
+            state.add_warning("Тестовое сообщение5")
+        state.add_info("Тестовое сообщение6")
+        state.add_info("Тестовое сообщение7")
+        state.add_info("Тестовое сообщение8")
+        if not no_warning:
+            state.add_warning("Тестовое сообщение9")
+        if not no_error:
+            state.add_error("Тестовое сообщение10")
+        
+        state.value = state_value
+        
+        return state
+    
+    def test_add_state (self):
+        state1 = ActionStateTest.get_test_state(True, True, True)
+        
+        state2 = ActionStateTest.get_test_state(state_value = False)
+        
+        state1.add_state(state2)
+        
+        self.assertEqual(16, state1.count())
+    
+    def test_get_messages (self):
+        state = ActionStateTest.get_test_state()
+        
+        state_messages = state.get_messages()
+        
+        self.assertEqual(10, len(state_messages))
+        
+        count_errors = 0
+        
+        for message in state_messages:
+            if message.message_type == MessageType.ERROR:
+                count_errors += 1
+        
+        self.assertEqual(2, count_errors)
+    
+    def test_get_string_messages (self):
+        state = ActionStateTest.get_test_state()
+        
+        state_message_string = state.get_string_messages(ActionState.get_string_error_only())
+        
+        need_string = "Тестовое сообщение2\nТестовое сообщение10"
+        
+        self.assertEqual(state_message_string, need_string)
+    
+    def test_has_infos (self):
+        state = ActionStateTest.get_test_state()
+        
+        self.assertTrue(state.has_infos())
+    
+    def test_has_warnings (self):
+        state = ActionStateTest.get_test_state()
+        
+        self.assertTrue(state.has_warnings())
+    
+    def test_has_errors (self):
+        state = ActionStateTest.get_test_state()
+        
+        self.assertTrue(state.has_errors())
+    
+    def test_is_success (self):
+        state_fail = ActionStateTest.get_test_state()
+        state_success = ActionStateTest.get_test_state(no_warning = True, no_error = True)
+        state_success_no_warning = ActionStateTest.get_test_state(no_error = True)
+        
+        self.assertTrue(state_success.is_success())
+        self.assertTrue(state_success_no_warning.is_success(True))
+        self.assertFalse(state_fail.is_success())
+    
+    def test_clear (self):
+        state = ActionStateTest.get_test_state()
+        
+        state.clear(lambda message: message.message_type == MessageType.WARNING)
+        
+        self.assertEqual(8, len(state.get_messages()))
+        
+        state.clear()
+        
+        self.assertEqual(0, len(state.get_messages()))
+    
+    def test_count (self):
+        state = ActionStateTest.get_test_state()
+        
+        count_all = state.count()
+        count_warnings = state.count(lambda message: message.message_type == MessageType.WARNING)
+        count_errors = state.count(lambda message: message.message_type == MessageType.ERROR)
+        count_errors_and_warnings = state.count(
+                lambda message: message.message_type == MessageType.WARNING or message.message_type == MessageType.ERROR
+                )
+        
+        self.assertEqual(10, count_all)
+        self.assertEqual(2, count_errors)
+        self.assertEqual(2, count_warnings)
+        self.assertEqual(4, count_errors_and_warnings)
+
+if __name__ == '__main__':
+    unittest.main()

tests/extensions/__init__.py

@@ -1 +1 @@
-# anb_python_components/extensions/__init__.py
+# tests/extensions/__init__.py

tests/extensions/bool_extension_test.py

@@ -1,21 +1,19 @@
-# string_extension_test.py
+# bool_extension_test.py
 
 import unittest
 
 from anb_python_components.extensions.bool_extension import *
 
-
 class BoolExtensionTest(unittest.TestCase):
-    def test_to_str(self):
+    def test_to_str (self):
         self.assertEqual(BoolExtension.to_str(True, "да", "нет"), "да")
         self.assertEqual(BoolExtension.to_str(False, "да", "нет"), "нет")
-
-    def test_true_count(self):
+    
+    def test_true_count (self):
         self.assertEqual(BoolExtension.true_count([False, True, False, True, True, False, False]), 3)
-
-    def test_any_true(self):
+    
+    def test_any_true (self):
         self.assertTrue(BoolExtension.any_true([False, True, False, True, True, False, False]))
 
-
 if __name__ == '__main__':
-    unittest.main()
+    unittest.main()

tests/types/__init__.py

@@ -0,0 +1 @@
+# tests/types/__init__.py

tests/types/guid_test.py

@@ -0,0 +1,78 @@
+# anb_python_components/types/guid.py
+import re
+
+from anb_python_components.exceptions.wrong_type_exception import WrongTypeException
+
+class GUID:
+    """
+    Тип GUID.
+    """
+    
+    # Константа пустого GUID
+    EMPTY: str = "00000000-0000-0000-0000-000000000000"
+    
+    def __init__ (self, guid = EMPTY):
+        """
+        Инициализация расширения.
+        :param guid: str | GUID - Передаваемый GUID
+        """
+        # Проверка типа аргумента guid
+        # - если аргумент не является строкой
+        if not isinstance(guid, str):
+            # -- если аргумент является экземпляром GUID
+            if isinstance(guid, GUID):
+                # - преобразуем его в строку
+                guid = str(guid)
+            else:
+                # -- иначе генерируем исключение
+                raise WrongTypeException("Неверный тип аргумента!", "GUID", str(type(guid)), "guid")
+        
+        # Проверка GUID на валидность
+        if not self.validate_str(guid):
+            # и если GUID невалидный, то генерируем исключение
+            raise WrongTypeException("Неверный формат GUID!", "GUID", guid, "guid")
+        
+        # Инициализируем приватный атрибут __value (текстовое представление хранящегося GUID)
+        self.__value = guid
+    
+    def __str__ (self):
+        """
+        Переопределение метода __str__.
+        :return: Текстовое представление GUID.
+        """
+        return self.__value if self.__value else self.EMPTY
+    
+    def __eq__ (self, other):
+        """
+        Переопределение метода __eq__.
+        :param other: Объект для сравнения.
+        :return: True, если GUID равны, иначе False.
+        """
+        
+        # Если аргумент не является экземпляром GUID
+        if not isinstance(other, GUID):
+            # - генерируем исключение
+            raise WrongTypeException("Неверный тип аргумента!", "GUID", type(other), "other")
+        
+        # Преобразование второго аргумента в строку
+        other_str = str(other)
+        
+        # Сравниваем строки
+        return self.__value == other_str
+    
+    @staticmethod
+    def validate_str (guid: str | None) -> bool:
+        """
+        Проверка строки на валидность GUID.
+        :return: True, если GUID валидный, иначе False.
+        """
+        
+        # Проверка на пустоту
+        if not guid:
+            return False
+        
+        # Регулярное выражение для проверки формата GUID
+        pattern = r'^[0-9A-Fa-f]{8}-([0-9A-Fa-f]{4}-){3}[0-9A-Fa-f]{12}$'
+        
+        # Проверка на соответствие формату
+        return bool(re.fullmatch(pattern, guid))

tests/types/two_dim_size_test.py

@@ -0,0 +1 @@
+# two_dim_size_test.py

tests/types/version_info_test.py

@@ -0,0 +1,51 @@
+# version_info_test.py
+
+import unittest
+
+from anb_python_components.types.version_info import VersionInfo
+
+class VersionInfoTest(unittest.TestCase):
+    def test_init (self):
+        version_info = VersionInfo(1, 2, 3, 4, "Тестовая версия", 1)
+        version_info_str = '1.2.3.4 Тестовая версия 1'
+        
+        self.assertEqual(version_info_str, str(version_info))
+    
+    def test_math (self):
+        version_info_1 = VersionInfo(1, 2, 3, 4, "Тестовая версия", 1)
+        version_info_2 = VersionInfo(1, 2, 3, 4, "Тестовая версия", 1)
+        version_info_3 = VersionInfo(2, 1, 3, 10, "Тестовая версия", 2)
+        version_info_4 = VersionInfo(3, 5, 3, 12, "Тестовая версия", 3)
+        
+        self.assertTrue(version_info_1 == version_info_2)
+        self.assertTrue(version_info_3 > version_info_2)
+        self.assertTrue(version_info_3 >= version_info_1)
+        self.assertTrue(version_info_1 < version_info_4)
+        self.assertTrue(version_info_3.in_range(version_info_1, version_info_4))
+        self.assertFalse(version_info_3.in_range(version_info_1, version_info_3, end_inclusive = False))
+        self.assertTrue(version_info_3.in_range(version_info_1))
+        self.assertTrue(version_info_3.in_range())
+    
+    def test_parse (self):
+        str_ver_1 = '1.2.3.4 Тестовая 1'
+        version_info_1 = VersionInfo(1, 2, 3, 4, "Тестовая", 1)
+        str_ver_2 = "1.2.3.4 Тестовая"
+        version_info_2 = VersionInfo(1, 2, 3, 4, "Тестовая", 0)
+        str_ver_3 = "1.2.3.4"
+        version_info_3 = VersionInfo(1, 2, 3, 4, "", 0)
+        str_ver_4 = "1.2.3 Тестовая 1"
+        version_info_4 = VersionInfo(1, 2, 3, 0, "Тестовая", 1)
+        str_ver_5 = "1.2 Тестовая 1"
+        version_info_5 = VersionInfo(1, 2, 0, 0, "Тестовая", 1)
+        str_ver_6 = "1 Тестовая 1"
+        version_info_6 = VersionInfo(1, 0, 0, 0, "Тестовая", 1)
+        
+        self.assertEqual(version_info_1, VersionInfo.parse(str_ver_1))
+        self.assertEqual(version_info_2, VersionInfo.parse(str_ver_2))
+        self.assertEqual(version_info_3, VersionInfo.parse(str_ver_3))
+        self.assertEqual(version_info_4, VersionInfo.parse(str_ver_4))
+        self.assertEqual(version_info_5, VersionInfo.parse(str_ver_5))
+        self.assertEqual(version_info_6, VersionInfo.parse(str_ver_6))
+
+if __name__ == '__main__':
+    unittest.main()