4.0.0 refactoring - some tests added

Author: InspiredImpact

multibar/api/__init__.py

@@ -8,15 +8,15 @@
 from .writers import *
 
 __all__ = (
-    "CalculationServiceAware",
+    "AbstractCalculationService",
     "ProgressbarClientAware",
     "ContractAware",
     "ContractCheck",
     "ContractManagerAware",
     "HookSignatureType",
     "HooksAware",
     "ProgressbarAware",
-    "SectorAware",
+    "AbstractSector",
     "SignatureSegmentProtocol",
     "ProgressbarSignatureProtocol",
     "ProgressbarWriterAware",

multibar/impl/contracts.py

@@ -10,7 +10,6 @@
 from returns.io import IO
 
 from multibar import errors, output
-from multibar import types as progress_types
 from multibar.api import contracts
 
 

multibar/settings.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 import collections.abc
-import copy
 import typing
 
 SelfT = typing.TypeVar("SelfT", bound="Settings")
@@ -14,8 +13,6 @@ def _config_get_function(self: SelfT, key: str) -> typing.Any:
 
 
 class Settings:
-    __slots__ = ("_config",)
-
     __getattr__ = __getitem__ = _config_get_function
 
     def __init__(self) -> None:
@@ -29,30 +26,11 @@ def __contains__(self, item: typing.Any) -> bool:
     def __copy__(self) -> Settings:
         return self.copy()
 
-    def __deepcopy__(
-        self,
-        memodict: typing.Optional[dict[int, typing.Any]] = None,
-        /,
-    ) -> Settings:
-        return self.deepcopy(memodict)
-
     def copy(self) -> Settings:
         new_instance = self.__class__()
         new_instance.configure(**self._config)
         return new_instance
 
-    def deepcopy(self, memodict: typing.Optional[dict[int, typing.Any]] = None, /) -> Settings:
-        if memodict is None:
-            memodict = {}
-
-        state = self.__class__()
-        memodict[id(self)] = state
-        for slot in self.__slots__:
-            self_value = getattr(self, slot)
-            setattr(state, slot, copy.deepcopy(self_value, memodict))
-
-        return state
-
     def configure(self, **kwargs: typing.Any) -> None:
         self._config.update(kwargs)
 

multibar/types.py

@@ -6,11 +6,7 @@
     from multibar.api import calculation_service, progressbars, sectors, signatures
 
 
-class ContractMetadata(typing.TypedDict, total=False):
-    pass
-
-
-class ProgressMetadataType(ContractMetadata, total=False):
+class ProgressMetadataType(typing.TypedDict, total=False):
     start_value: int
     end_value: int
     length: int

multibar/utils.py

@@ -1,4 +1,4 @@
-__all__ = ["none_or"]
+__all__ = ["none_or", "cached_property"]
 
 import typing
 
@@ -33,15 +33,9 @@ def __get__(
         instance: object,
         owner: typing.Optional[typing.Type[typing.Any]] = None,
     ) -> typing.Any:
-        if not hasattr(instance, "__dict__"):
-            # For correct execution of cls.update_cache_for
-            return self.func
         result = instance.__dict__[self.func.__name__] = self.func(instance)
         return result
 
     @classmethod
-    def update_cache_for(cls, state: object, prop_name: str) -> None:
-        state_type = type(state)
-        origin = getattr(state_type, prop_name)
-        delattr(state, prop_name)
-        setattr(state_type, prop_name, cls(origin))
+    def update_cache_for(cls, state: object, prop_name: str, /) -> None:
+        del state.__dict__[prop_name]

tests/pyhamcrest.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+__all__ = ("subclass_of",)
+
+import typing
+
+from hamcrest.core.base_matcher import BaseMatcher
+
+if typing.TYPE_CHECKING:
+    from hamcrest.core.description import Description
+
+
+class IsSubclassOf(BaseMatcher):
+    def __init__(
+        self,
+        cls_or_tuple: typing.Union[typing.Type[typing.Any], tuple[typing.Type[typing.Any], ...]], /
+    ) -> None:
+        self._cls_or_tuple = cls_or_tuple
+        self.failed: typing.Optional[str] = None
+
+    def _matches(self, cls: typing.Type[typing.Any]) -> bool:
+        result = issubclass(cls, self._cls_or_tuple)
+        if not result:
+            self.failed = cls
+        return result
+
+    def describe_to(self, description: Description) -> None:
+        (
+            description.append_text("failing on ").append_text(
+                f"<{self.failed}> attribute"
+            )
+        )
+
+
+def subclass_of(
+    cls_or_tuple: typing.Union[typing.Type[typing.Any], tuple[typing.Type[typing.Any], ...]], /
+) -> IsSubclassOf:
+    return IsSubclassOf(cls_or_tuple)
+

tests/unit/impl/test_calctulation_service.py

@@ -0,0 +1,34 @@
+from hamcrest import assert_that, equal_to, has_properties, instance_of, has_length
+
+from multibar import iterators
+from multibar.impl.calculation_service import ProgressbarCalculationService
+
+
+def test_percentage() -> None:
+    percentage = ProgressbarCalculationService.get_progress_percentage(50, 100)
+    assert_that(percentage, equal_to(50.0))
+
+
+def test_calculation_service() -> None:
+    calc_service = ProgressbarCalculationService(50, 100, 20)
+
+    assert_that(
+        calc_service,
+        has_properties(
+            {
+                "start_value": equal_to(50),
+                "end_value": equal_to(100),
+                "length_value": equal_to(20),
+                "progress_percents": equal_to(50.0),
+            }
+        )
+    )
+
+    first_part = calc_service.calculate_filled_indexes()
+    second_part = calc_service.calculate_unfilled_indexes()
+
+    assert_that(first_part, instance_of(iterators.AbstractIterator))
+    assert_that(second_part, instance_of(iterators.AbstractIterator))
+
+    assert_that(list(first_part), has_length(calc_service.length_value // 2))
+    assert_that(list(second_part), has_length(calc_service.length_value // 2))

tests/unit/test_iterators.py

@@ -0,0 +1,27 @@
+import collections.abc
+
+import pytest
+from hamcrest import assert_that, instance_of, is_in, equal_to
+
+from multibar import iterators
+from tests.pyhamcrest import subclass_of
+
+
+def test_iterator() -> None:
+    iterator = iterators.Iterator(iter(()))
+
+    assert_that(iterators.Iterator, subclass_of(collections.abc.Iterator))
+    assert_that(iterator, instance_of(collections.abc.Iterator))
+
+    assert_that("_iterator", is_in(iterator.__slots__))
+
+    with pytest.raises(StopIteration):
+        next(iterator)
+
+
+def test_convertable_index_iterator() -> None:
+    iterator1 = iterators.Iterator(iter((24, 235, 34)))
+    assert_that(list(iterator1.indexes()), equal_to([0, 1, 2]))
+
+    iterator2 = iterators.Iterator(iter((34, 6546, 32)))
+    assert_that(list(iterator2.indexes(conversion=lambda i: i + 1)), equal_to([1, 2, 3]))

tests/unit/test_settings.py

@@ -0,0 +1,58 @@
+import copy
+
+from hamcrest import assert_that, is_in, instance_of, equal_to, calling, raises, not_
+
+from multibar.settings import settings
+
+
+class TestSettings:
+    def test_settings_copy(self) -> None:
+        settings_copy = settings.copy()
+        supports_copy = copy.copy(settings)
+
+        settings_copy.configure(key="value")
+
+        assert_that("key", is_in(settings_copy))
+        assert_that("key", not_(is_in(settings)))
+
+        supports_copy.configure(key="value")
+
+        assert_that("key", is_in(supports_copy))
+        assert_that("key", not_(is_in(settings)))
+
+    def test_settings_state(self) -> None:
+        mock_settings = settings.copy()
+
+        assert_that("_config", is_in(mock_settings.__dict__))
+
+    def test_settings_get(self) -> None:
+        mock_settings = settings.copy()
+        mock_settings.__dict__["__dunder__"] = "I'm dunder."
+
+        assert_that(mock_settings.__dunder__, instance_of(str))
+        assert_that(mock_settings["__dunder__"], instance_of(str))
+
+        mock_settings.configure(non_dunder="non_dunder")
+
+        assert_that(mock_settings.non_dunder, equal_to("non_dunder"))
+        assert_that(mock_settings["non_dunder"], equal_to("non_dunder"))
+
+        mock_settings.configure(__new_dunder__="new_dunder")
+
+        # Because all dunder-attrs getting from self.__dict__
+        assert_that(calling(lambda: mock_settings["__new_dunder__"]), raises(KeyError))
+        assert_that(calling(lambda: mock_settings.__new_dunder__), raises(KeyError))
+
+    def test_setting_in(self) -> None:
+        mock_settings = settings.copy()
+
+        class NonHashableMock:
+            __hash__ = None
+
+        non_hashable_mock = NonHashableMock()
+        mock_settings.configure(non_hashable=non_hashable_mock)
+
+        # Hashable keys are searching in dict.keys()
+        assert_that("non_hashable", is_in(mock_settings))
+        # Non-hashable keys are searching in dict.values()
+        assert_that(non_hashable_mock, is_in(mock_settings))

tests/unit/test_utils.py

@@ -0,0 +1,58 @@
+from hamcrest import assert_that, not_, is_in, equal_to
+
+from multibar.utils import cached_property, none_or
+
+
+class MockClass:
+    def __init__(self) -> None:
+        self.state_attr: int = 2
+
+    @cached_property
+    def mock_property(self) -> int:
+        return self.state_attr ** 1_000
+
+
+class TestCachedProperty:
+    def test_assert_property_in_cache(self) -> None:
+        fake_instance = MockClass()
+        assert_that("mock_property", not_(is_in(fake_instance.__dict__)))
+
+        # Getting attr for prop caching
+        getattr(fake_instance, "mock_property")
+
+        assert_that("mock_property", is_in(fake_instance.__dict__))
+
+    def test_cachedproperty_update_cache(self) -> None:
+        fake_instance = MockClass()
+        assert_that("mock_property", not_(is_in(fake_instance.__dict__)))
+
+        # Getting attr for prop caching
+        raw_value = fake_instance.mock_property
+
+        assert_that("mock_property", is_in(fake_instance.__dict__))
+
+        fake_instance.state_attr = 3
+        value_from_cache = fake_instance.mock_property
+        assert_that(value_from_cache, equal_to(raw_value))
+
+        cached_property.update_cache_for(fake_instance, "mock_property")
+        # Getting attr for updating prop cache
+        new_raw_value = fake_instance.mock_property
+        new_value_from_cache = fake_instance.mock_property
+
+        assert_that(new_raw_value, equal_to(new_value_from_cache))
+        assert_that(new_raw_value, not_(equal_to(value_from_cache)))
+
+
+class TestNoneOr:
+    def test_actual_is_none(self) -> None:
+        cls = None
+        result = none_or(int, cls)
+
+        assert_that(result, equal_to(int))
+
+    def test_actual_is_not_none(self) -> None:
+        cls = float
+        result = none_or(int, cls)
+
+        assert_that(result, equal_to(float))