anb-python-components 1.2.1__py3-none-any.whl

tests/custom_types/object_array_test.py

@@ -0,0 +1,160 @@
+# tests/custom_types/object_array_test.py
+
+import unittest
+
+from anb_python_components.custom_types.object_array import ObjectArray
+
+class TestClass:
+    def __init__ (self, key, value):
+        self.key = key
+        self.value = value
+
+class ObjectArrayTest(unittest.TestCase):
+    def test_init (self):
+        array = ObjectArray[int]([1, 2, 3])
+        
+        self.assertEqual(3, len(array))
+    
+    @staticmethod
+    def _create_array () -> ObjectArray[int]:
+        return ObjectArray[int]([1, 2, 3])
+    
+    def test_get (self):
+        array = self._create_array()
+        
+        item = array[0]
+        
+        self.assertEqual(1, item)
+    
+    def test_set (self):
+        array = self._create_array()
+        
+        array[0] = 4
+        
+        self.assertEqual(4, array[0])
+    
+    def test_add (self):
+        array = self._create_array()
+        array.add(4)
+        
+        self.assertEqual(4, array[3])
+    
+    def test_add_range (self):
+        array = self._create_array()
+        
+        array.add_range([4, 5, 6])
+        
+        self.assertEqual(4, array[3])
+        self.assertEqual(6, len(array))
+    
+    def test_to_array (self):
+        array = self._create_array()
+        
+        self.assertEqual([1, 2, 3], array.to_array())
+    
+    def test_find (self):
+        array = self._create_array()
+        
+        self.assertEqual(3, array.find(3))
+    
+    def test_sort (self):
+        array = ObjectArray[TestClass]([TestClass(1, 3), TestClass(3, 2), TestClass(2, 1)])
+        array.sort('key')
+        
+        self.assertEqual(2, array[1].key)
+    
+    def test_sort_callback (self):
+        array = self._create_array()
+        
+        array.sort_callback(lambda a: a, True)
+        
+        self.assertEqual(3, array[0])
+    
+    def test_count (self):
+        array = self._create_array()
+        
+        self.assertEqual(1, array.count(lambda a: a == 1))
+    
+    def test_is_exists (self):
+        array = self._create_array()
+        
+        self.assertTrue(array.is_exists(lambda a: a == 3))
+        self.assertFalse(array.is_exists(lambda a: a == 4))
+    
+    def test_min_max (self):
+        array = self._create_array()
+        
+        self.assertEqual(1, array.min(lambda a: a))
+        self.assertEqual(3, array.max(lambda a: a))
+    
+    def test_get_rows (self):
+        array = self._create_array()
+        
+        self.assertEqual(2, len(array.get_rows(lambda a: a != 2)))
+        self.assertEqual(3, len(array.get_rows()))
+    
+    def test_get_row (self):
+        array = self._create_array()
+        
+        self.assertEqual(3, array.get_row(lambda a: a == 3))
+    
+    def test_where (self):
+        array = self._create_array()
+        
+        self.assertEqual(3, array.where(lambda a: a == 3))
+        self.assertEqual(None, array.where(lambda a: a == 4))
+        self.assertEqual(2, len(array.where(lambda a: a != 2)))
+    
+    def test_get_column (self):
+        array = ObjectArray[TestClass]([TestClass(1, 3), TestClass(3, 2), TestClass(2, 1)])
+        
+        get_column1 = array.get_column('key')
+        get_column2 = array.get_column('key', lambda a: a.key != 3)
+        
+        self.assertEqual([1, 3, 2], get_column1.to_array())
+        self.assertEqual([1, 2], get_column2.to_array())
+    
+    def test_get_column_callback (self):
+        array = ObjectArray[TestClass]([TestClass(1, 3), TestClass(3, 2), TestClass(2, 1)])
+        
+        get_column_callback = array.get_column_callback(lambda a: a.value, lambda a: a.key != 3)
+        
+        self.assertEqual([3, 1], get_column_callback.to_array())
+    
+    def test_get_value (self):
+        array = ObjectArray[TestClass]([TestClass(1, 3), TestClass(3, 2), TestClass(2, 1)])
+        
+        self.assertEqual(2, array.get_value('value', lambda a: a.key == 3))
+    
+    def test_delete (self):
+        array = self._create_array()
+        
+        array.delete(lambda a: a == 2)
+        self.assertEqual(2, len(array))
+        
+        array.delete()
+        self.assertEqual(0, len(array))
+    
+    def test_first_and_last (self):
+        array = self._create_array()
+        
+        self.assertEqual(1, array.first(0))
+        self.assertEqual(3, array.last(0))
+    
+    def test_skip (self):
+        array = self._create_array()
+        
+        self.assertEqual([2, 3], array.skip(1).to_array())
+    
+    def test_take (self):
+        array = self._create_array()
+        
+        self.assertEqual([1, 2], array.take(2).to_array())
+    
+    def test_skip_and_take (self):
+        array = self._create_array()
+        
+        self.assertEqual([2], array.skip(1).take(1).to_array())
+
+if __name__ == '__main__':
+    unittest.main()

tests/custom_types/two_dim_size_test.py

@@ -0,0 +1,37 @@
+# tests/custom_types/two_dim_size_test.py
+
+import unittest
+
+from anb_python_components.custom_types.two_dim_size import TwoDimSize
+
+class TwoDimSizeTest(unittest.TestCase):
+    def test_init (self):
+        size = TwoDimSize(1, 2)
+        
+        self.assertEqual(size.width, 1)
+        self.assertEqual(size.height, 2)
+        
+        size = TwoDimSize(1, 5, 3, max_height = 4)
+        self.assertEqual(size.width, 3)
+        self.assertEqual(size.height, 4)
+    
+    def test_math (self):
+        size_1 = TwoDimSize(1, 2)
+        size_2 = TwoDimSize(3, 4)
+        size_3 = size_1 + size_2
+        
+        self.assertEqual(size_3.width, 4)
+        self.assertEqual(size_3.height, 6)
+        
+        self.assertTrue(size_3 == TwoDimSize(4, 6))
+    
+    def test_parse (self):
+        str_size = "1x2"
+        
+        size = TwoDimSize.parse(str_size, 'x')
+        
+        self.assertEqual(size.width, 1)
+        self.assertEqual(size.height, 2)
+
+if __name__ == '__main__':
+    unittest.main()

tests/custom_types/version_info_test.py

@@ -0,0 +1,51 @@
+# tests/custom_types/version_info_test.py
+
+import unittest
+
+from anb_python_components.custom_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()

tests/extensions/__init__.py

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

tests/extensions/array_extension_test.py

@@ -0,0 +1,21 @@
+# array_extension_test.py
+
+import unittest
+
+from anb_python_components.extensions.array_extension import ArrayExtension
+
+
+class ArrayExtensionTest(unittest.TestCase):
+    def test_remove_empties(self):
+        array = ["Мама", "Папа", "", "", "он", "", "она", "вместе", "", "дружная", "", "семья", ""]
+
+        removed_empties = ["Мама", "Папа", "он", "она", "вместе", "дружная", "семья"]
+
+        sorted_removed_empties = ["Мама", "Папа", "вместе", "дружная", "он", "она", "семья"]
+
+        self.assertEqual(removed_empties, ArrayExtension.remove_empties(array))
+        self.assertEqual(sorted_removed_empties, ArrayExtension.remove_empties(array, True))
+
+
+if __name__ == '__main__':
+    unittest.main()

tests/extensions/bool_extension_test.py

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

tests/extensions/string_extension_test.py

@@ -0,0 +1,55 @@
+# string_extension_test.py
+
+import unittest
+
+from anb_python_components.extensions.string_extension import *
+
+
+class StringExtensionTest(unittest.TestCase):
+    def test_is_none_or_empty(self):
+        self.assertTrue(StringExtension.is_none_or_empty(None))
+        self.assertTrue(StringExtension.is_none_or_empty(""))
+        self.assertFalse(StringExtension.is_none_or_empty("Некий текст"))
+        self.assertFalse(StringExtension.is_none_or_empty(" "))
+
+    def test_is_none_or_whitespace(self):
+        self.assertTrue(StringExtension.is_none_or_whitespace(None))
+        self.assertTrue(StringExtension.is_none_or_whitespace(""))
+        self.assertFalse(StringExtension.is_none_or_whitespace("Некий текст"))
+        self.assertTrue(StringExtension.is_none_or_whitespace(" "))
+
+    def test_is_russian_letter(self):
+        self.assertTrue(StringExtension.is_russian_letter('п'))
+        self.assertFalse(StringExtension.is_russian_letter("p"))
+
+    def test_get_russian_letter_transliteration(self):
+        self.assertEqual(StringExtension.get_russian_letter_transliteration('Ю'), 'Yu')
+        self.assertNotEqual(StringExtension.get_russian_letter_transliteration('я'), 'Yu')
+
+    def test_convert_to_latin(self):
+        self.assertEqual(StringExtension.convert_to_latin('Россия'), 'Rossiya')
+
+    def test_compare(self):
+        self.assertEqual(StringExtension.compare('Россия', 'Россия'), 0)
+        self.assertEqual(StringExtension.compare('Россия', 'Россия', True), 0)
+        self.assertEqual(StringExtension.compare('Россия', 'россия', True), 0)
+        self.assertEqual(StringExtension.compare('Россия', 'россия'), 1)
+        self.assertEqual(StringExtension.compare('Россия - Великая держава', 'Россия'), 1)
+        self.assertEqual(StringExtension.compare('Россия', 'Россия, мы гордимся Тобою'), -1)
+
+    def test_get_short_text(self):
+        self.assertEqual(StringExtension.get_short_text('Я люблю Python', 10), 'Я люблю Py')
+        self.assertEqual(StringExtension.get_short_text('Я люблю Python', 10, '...'), 'Я люблю...')
+
+    def test_replace(self):
+        self.assertEqual(StringExtension.replace('Я люблю Python. Хотя только изучаю сам Python', 'Python', 'PHP'),
+                         "Я люблю PHP. Хотя только изучаю сам PHP")
+
+    def test_replace_all(self):
+        self.assertEqual(StringExtension.replace_all({'Python': 'PHP', 'сам': 'последнюю версию'},
+                                                     'Я люблю Python. Хотя только изучаю сам Python'),
+                         "Я люблю PHP. Хотя только изучаю последнюю версию PHP")
+
+
+if __name__ == '__main__':
+    unittest.main()

tests/extensions/type_extension_test.py

@@ -0,0 +1,38 @@
+# type_extension_test.py
+
+import unittest
+
+from anb_python_components.extensions.type_extension import TypeExtension
+from anb_python_components.custom_types.guid import GUID
+
+class DemoClass:
+    def __init__ (self, name):
+        self.name = name
+        self.age = 20
+
+class TypeExtensionTest(unittest.TestCase):
+    
+    def test_to_dict (self):
+        converted = TypeExtension.to_dict(DemoClass('Иван'))
+        self.assertEqual(converted, {'name': 'Иван', 'age': 20})
+    
+    def test_from_dict (self):
+        # Представим данные в виде словаря
+        data = {'name': 'Иван', 'age': 20}
+        
+        # Преобразуем данные в объект DemoClass
+        converted = TypeExtension.from_dict(data, DemoClass)
+        
+        # Проверяем, что полученный объект является экземпляром DemoClass
+        self.assertIsInstance(converted, DemoClass)
+        
+        # Проверяем, что объект содержит ожидаемые значения
+        self.assertEqual(converted.name, 'Иван')
+        self.assertEqual(converted.age, 20)
+    
+    def test_is_immutable_type (self):
+        self.assertTrue(TypeExtension.is_immutable_type(int))
+        self.assertFalse(TypeExtension.is_immutable_type(GUID))
+
+if __name__ == '__main__':
+    unittest.main()