test: add/modify tests to bring back coverage to 100%

Author: sassanh

CHANGELOG.md

@@ -3,6 +3,7 @@
 ## Upcoming
 
 - fix: add `__name__` to `WithStore` instances so that they play nice when passed as a function to something assuming they are functions and have a `__name__` attribute
+- test: add/modify tests to bring back coverage to 100%
 
 ## Version 0.22.0
 

tests/results/test_weakref/subscription/store-000.jsonc

@@ -84,16 +84,41 @@ def store() -> Generator[StoreType, None, None]:
 
 def test_general(store_snapshot: StoreSnapshot, store: StoreType) -> None:
     @store.autorun(lambda state: state.value)
-    def decorated(value: int) -> int:
+    def _(value: int) -> int:
         store_snapshot.take()
         return value
 
+
+def test_name(store: StoreType) -> None:
+    """Test `autorun` decorator name attribute."""
+
+    @store.autorun(lambda state: state.value)
+    def decorated(value: int) -> int:
+        return value
+
     assert decorated.__name__ == 'Autorun:decorated'
 
+    inline_decorated = store.autorun(lambda state: state.value)(
+        lambda value: value,
+    )
+
+    assert inline_decorated.__name__ == 'Autorun:<lambda>'
+
+    class Decorated:
+        def __call__(self, value: int) -> int:
+            return value
+
+        def __repr__(self) -> str:
+            return 'Decorated'
+
+    decorated_instance = store.autorun(lambda state: state.value)(Decorated())
+
+    assert decorated_instance.__name__ == 'Autorun:Decorated'
+
 
 def test_ignore_attribute_error_in_selector(store: StoreType) -> None:
     @store.autorun(lambda state: cast('Any', state).non_existing)
-    def _(_: int) -> int:
+    def _(_: int) -> None:
         pytest.fail('This should never be called')
 
 
@@ -102,7 +127,7 @@ def test_ignore_attribute_error_in_comparator(store: StoreType) -> None:
         lambda state: state.value,
         lambda state: cast('Any', state).non_existing,
     )
-    def _(_: int) -> int:
+    def _(_: int) -> None:
         pytest.fail('This should never be called')
 
 

tests/results/test_weakref/subscription/store-001.jsonc

@@ -237,28 +237,36 @@ def render(value: int) -> int:
     store.dispatch(IncrementAction())
 
 
-def test_subscription(
-    store_snapshot: StoreSnapshot,
-    store: StoreType,
-) -> None:
+def test_subscription(store: StoreType) -> None:
+    with_ref_counter = []
+
     def subscription_with_keep_ref(_: StateType) -> None:
-        store_snapshot.take()
+        with_ref_counter.append(None)
 
     store._subscribe(subscription_with_keep_ref)  # noqa: SLF001
+
     ref = weakref.ref(subscription_with_keep_ref)
     del subscription_with_keep_ref
     assert ref() is not None
 
+    without_ref_counter = []
+
     def subscription_without_keep_ref(_: StateType) -> None:
-        pytest.fail('This should never be called')
+        without_ref_counter.append(None)
 
     store._subscribe(subscription_without_keep_ref, keep_ref=False)  # noqa: SLF001
+
+    store.dispatch(IncrementAction())
+
     ref = weakref.ref(subscription_without_keep_ref)
     del subscription_without_keep_ref
     assert ref() is None
 
     store.dispatch(IncrementAction())
 
+    assert len(with_ref_counter) == 2
+    assert len(without_ref_counter) == 1
+
 
 def test_subscription_method(
     store_snapshot: StoreSnapshot,

tests/test_autorun.py

@@ -2,6 +2,8 @@
 
 from __future__ import annotations
 
+import inspect
+import re
 from dataclasses import replace
 from typing import TYPE_CHECKING
 
@@ -54,6 +56,110 @@ def _() -> StoreType:
     return Store(_reducer, options=CreateStoreOptions(auto_init=False))
 
 
+def test_name_attr(store: StoreType) -> None:
+    """Test `with_state` decorator name attribute."""
+
+    @store.with_state(lambda state: state.value)
+    def decorated(value: int) -> int:
+        return value
+
+    assert decorated.__name__ == 'WithState:decorated'
+
+    inline_decorated = store.with_state(lambda state: state.value)(
+        lambda value: value,
+    )
+
+    assert inline_decorated.__name__ == 'WithState:<lambda>'
+
+    class Decorated:
+        def __call__(self, value: int) -> int:
+            return value
+
+        def __repr__(self) -> str:
+            return 'Decorated'
+
+    decorated_instance = store.with_state(lambda state: state.value)(Decorated())
+
+    assert decorated_instance.__name__ == 'WithState:Decorated'
+
+    store.dispatch(InitAction())
+    store.dispatch(FinishAction())
+
+
+def test_repr(store: StoreType) -> None:
+    """Test `with_state` decorator `__repr__` method."""
+
+    @store.with_state(lambda state: state.value)
+    def func(value: int) -> int:
+        return value
+
+    assert re.match(
+        r'.*\(func: <function test_repr\.<locals>\.func at .*>\)$',
+        repr(func),
+    )
+
+    store.dispatch(InitAction())
+    store.dispatch(FinishAction())
+
+
+def test_signature(store: StoreType) -> None:
+    """Test `with_state` decorator `__signature__` attribute."""
+
+    @store.with_state(lambda state: state.value)
+    def func(
+        value: int,
+        some_positional_parameter: str,
+        some_positional_parameter_with_default: int = 0,
+        *,
+        some_keyword_parameter: bool,
+        some_keyword_parameter_with_default: int = 1,
+    ) -> int:
+        _ = (
+            some_positional_parameter,
+            some_positional_parameter_with_default,
+            some_keyword_parameter,
+            some_keyword_parameter_with_default,
+        )
+        return value
+
+    signature = inspect.signature(func)
+    assert len(signature.parameters) == 4
+
+    assert 'some_positional_parameter' in signature.parameters
+    assert (
+        signature.parameters['some_positional_parameter'].default
+        is inspect.Parameter.empty
+    )
+    assert signature.parameters['some_positional_parameter'].annotation == 'str'
+
+    assert 'some_positional_parameter_with_default' in signature.parameters
+    assert signature.parameters['some_positional_parameter_with_default'].default == 0
+    assert (
+        signature.parameters['some_positional_parameter_with_default'].annotation
+        == 'int'
+    )
+
+    assert 'some_keyword_parameter' in signature.parameters
+    assert (
+        signature.parameters['some_keyword_parameter'].default
+        is inspect.Parameter.empty
+    )
+    assert signature.parameters['some_keyword_parameter'].annotation == 'bool'
+
+    assert 'some_keyword_parameter_with_default' in signature.parameters
+    assert signature.parameters['some_keyword_parameter_with_default'].default == 1
+    assert (
+        signature.parameters['some_keyword_parameter_with_default'].annotation == 'int'
+    )
+
+    assert 'value' not in signature.parameters
+
+    assert signature.return_annotation == 'int'
+
+    store.dispatch(InitAction())
+    store.dispatch(FinishAction())
+
+
 def test_with_state(store: StoreType) -> None:
     """Test `with_state` decorator."""
     counter = 0