refactor(type-checking): static type checking with mypy of test code (along with prod code)

Author: boromir674

docs/introduction.rst

@@ -3,28 +3,27 @@ Introduction
 
 In these documentation pages we present the `software_patterns` Python package and the motivation
 for publishing it. The package currently host only a handful of software patterns, but they come with
-a test suite and full CI for local and remote integrations.
+a test suite and full CI for local and remote builds.
 
 
 Why would this project be useful to you?
 ========================================
 
+To develop your code, while abstracting common software patterns away and focus on important business logic.
+------------------------------------------------------------------------------------------------------------
+
+- To promote the DRY prinicipal in your codebase.
+- To promote the principal of Single Responsibility in your codebase.
+- To promote having Simple Units of Code in your codebase.
+- To keep technical debt low in your codebase.
+
 To Learn:
 ---------
 
 - You may study the source code to find out more about software design patterns.
 - You may wanna learn how to make an open source code contribution and find this codebase a good place to start.
 
 
-To use the python package and its contained software patterns in your project:
-------------------------------------------------------------------------------
-
-- To promote good software quality in your python codebase.
-- To promote the DRY prinicipal in your client code.
-- To promote the principal of Single Responsibility in your client code.
-- To promote having Simple Units of Code in your project.
-
-
 Why use this Python Patterns library?
 =====================================
 

src/software_patterns/notification.py

@@ -25,12 +25,13 @@
 """
 
 from abc import ABC, abstractmethod
-from typing import Generic, List, TypeVar
+from typing import Generic, List, TypeVar, Union
 
 __all__ = ['Subject', 'Observer']
 
 
 StateType = TypeVar('StateType')
+StateVariableType = Union[StateType, None]
 
 
 class ObserverInterface(ABC):
@@ -125,7 +126,7 @@ class Subject(SubjectInterface, Generic[StateType]):
 
     def __init__(self, *args, **kwargs):
         self._observers: List[ObserverInterface] = []
-        self._state = None
+        self._state = StateVariableType
 
     def attach(self, observer: ObserverInterface) -> None:
         self._observers.append(observer)
@@ -142,7 +143,7 @@ def add(self, *observers):
         self._observers.extend(list(observers))
 
     @property
-    def state(self) -> StateType:
+    def state(self) -> StateVariableType:
         """Get the state of the Subject.
 
         Returns:

src/software_patterns/singleton.py

@@ -13,7 +13,6 @@ class Singleton(type):
 
         >>> class ObjectDict(metaclass=Singleton):
         ...  def __init__(self):
-        ...   super().__init__()
         ...   self.objects = {}
 
         >>> reg1 = ObjectDict()

tests/test_notification.py

@@ -1,31 +1,49 @@
+import typing as t
+
 import pytest
 
+from software_patterns import Observer, Subject
+
+# class SubjectLike(t.Protocol):
+#     state: t.Any
+
+# class ObserverLike(t.Protocol):
+#     update: t.Callable[[SubjectLike, t.Any], None]
+
 
-@pytest.fixture
-def subject():
-    from software_patterns import Subject
+# @pytest.fixture
+# def subject():
+#     from software_patterns import Subject
 
-    return Subject
+#     return Subject
 
 
-@pytest.fixture
-def observer():
-    from software_patterns import Observer
+# @pytest.fixture
+# def observer() -> t.Type[Observer]:
+#     """Observer Abstract Class that acts as an Observer interface.
 
-    return Observer
+#     The Client code is expected to implement the 'update' method of the
+#     interface.
+#     """
+#     from software_patterns import Observer
 
+#     return Observer
 
-def test_observers_sanity_test1(subject):
-    subject1 = subject([])
-    subject2 = subject([])
+
+def test_observers_sanity_test():
+    subject1: Subject = Subject([])
+    subject2: Subject = Subject([])
     assert hasattr(subject1, '_observers')
     assert hasattr(subject2, '_observers')
     assert id(subject1._observers) != id(subject2._observers)
 
 
-def test_observer_as_constructor(observer):
+# def test_observer_as_constructor(observer: t.Type[Observer]):
+def test_observer_as_constructor():
+    observer = Observer
+
     with pytest.raises(TypeError) as instantiation_from_interface_error:
-        _observer_instance = observer()
+        _observer_instance = observer()  # type: ignore[abstract]
 
     import re
 
@@ -38,26 +56,24 @@ def test_observer_as_constructor(observer):
     )
 
 
-def test_scenario(subject, observer):
+# def test_scenario(subject: t.Type[Subject], observer: t.Type[Observer]):
+def test_scenario():
+    # Scenario 1
     # The client code.
-
-    print("------ Scenario 1 ------\n")
-
-    class ObserverA(observer):
+    class ObserverA(Observer):
         def update(self, a_subject) -> None:
             print("ObserverA: Reacted to the event")
 
-    s1 = subject([])
+    s1: Subject = Subject([])
     o1 = ObserverA()
     s1.attach(o1)
 
     # business logic
     s1.state = 0
     s1.notify()
 
-    print("------ Scenario 2 ------\n")
-    # example 2
-    class Businessubject(subject):
+    # Scenario 2
+    class Businessubject(Subject):
         def some_business_logic(self) -> None:
             """
             Usually, the subscription logic is only a fraction of what a Subject can
@@ -70,7 +86,7 @@ def some_business_logic(self) -> None:
             print(f"Subject: My state has just changed to: {self._state}")
             self.notify()
 
-    class ObserverB(observer):
+    class ObserverB(Observer):
         def update(self, a_subject) -> None:
             if a_subject.state == 0 or a_subject.state >= 2:
                 print("ObserverB: Reacted to the event")

tests/test_proxy.py

@@ -1,13 +1,6 @@
 import pytest
 
 
-@pytest.fixture
-def proxy_module():
-    from software_patterns import proxy
-
-    return proxy
-
-
 @pytest.fixture
 def dummy_handle():
     def handle(self, *args, **kwargs):
@@ -16,11 +9,12 @@ def handle(self, *args, **kwargs):
     return handle
 
 
-def test_proxy_behaviour(proxy_module, dummy_handle, capsys):
-    prm = proxy_module
+def test_proxy_behaviour(dummy_handle, capsys):
+    from typing import List
 
-    # replicate client code that wants to use the proxy pattern
+    from software_patterns import proxy as prm
 
+    # replicate client code that wants to use the proxy pattern
     # Derive from class RealSubject or use 'python overloading' (use a class
     # that has a 'request' method with the same signature as ReadSubject.request)
     class ClientSubject(prm.ProxySubject):
@@ -57,7 +51,7 @@ def _dummy_callback(*args, **kwargs):
     # use proxy in a scenario
 
     # First test what happens without using proxy
-    args = [1, 2]
+    args: List = [1, 2]
     kwargs = {'k1': 'v1'}
     result = real_subject.request(*args, **kwargs)
 
@@ -74,6 +68,7 @@ def _dummy_callback(*args, **kwargs):
     result = proxy.request(*args, **kwargs)
 
     captured = capsys.readouterr()
+
     assert (
         captured.out
         == dummy_handle(*list([proxy, 'before'] + args), **kwargs)

tests/test_singleton.py

@@ -1,21 +1,62 @@
 import typing as t
 
+import pytest
+
 from software_patterns import Singleton
 
 
-def test_singleton():
+def test_singleton(assert_same_objects):
     class MySingleton(metaclass=Singleton):
-        def __init__(self, data: t.Mapping):
+        def __init__(self, data: t.MutableMapping):
             self.data = data
 
     instance_1 = MySingleton({'a': 1})
     instance_2 = MySingleton({'b': 2})
 
-    assert id(instance_1) == id(instance_2)
+    assert_same_objects(instance_1, instance_2)
+
     assert instance_1.data['a'] == instance_2.data['a'] == 1
     assert 'b' not in instance_1.data
     assert 'b' not in instance_2.data
 
     instance_1.data['c'] = 0
 
     assert instance_2.data['c'] == 0
+
+
+@pytest.fixture
+def assert_same_objects():
+    def _assert_same_objects(obj1, obj2):
+        assert id(obj1) == id(obj2)
+        attributes_1 = list(dir(obj1))
+        attributes_2 = list(dir(obj2))
+        assert attributes_1 == attributes_2
+        for attr_name in set(attributes_1).difference(
+            {
+                '__delattr__',
+                '__init__',
+                '__gt__',
+                '__ne__',
+                '__dir__',
+                '__repr__',
+                '__setattr__',
+                '__le__',
+                '__subclasshook__',
+                '__str__',
+                '__format__',
+                '__lt__',
+                '__eq__',
+                '__reduce_ex__',
+                '__getattribute__',
+                '__reduce__',
+                '__init_subclass__',
+                '__hash__',
+                '__sizeof__',
+                '__ge__',
+            }
+        ):
+            print(attr_name)
+            assert getattr(obj1, attr_name) == getattr(obj2, attr_name)
+            assert id(getattr(obj1, attr_name)) == id(getattr(obj2, attr_name))
+
+    return _assert_same_objects