feat!: rework how enumeration works, now you have to create a new class of type Enum

Signed-off-by: Adria Montoto <75563346+adriamontoto@users.noreply.github.com>

Author: adriamontoto

object_mother_pattern/mothers/enumeration_mother.py

@@ -2,18 +2,26 @@
 EnumerationMother module.
 """
 
+from abc import ABC
 from datetime import date, datetime
 from enum import Enum
+from inspect import isclass
 from random import choice
-from typing import Any, Generic, Iterable, TypeVar
+from sys import version_info
+from typing import Any, Generic, Iterable, TypeVar, get_args, get_origin
 from uuid import UUID, uuid4
 
+if version_info >= (3, 12):
+    from typing import override  # pragma: no cover
+else:
+    from typing_extensions import override  # pragma: no cover
+
 from faker import Faker
 
 E = TypeVar('E', bound=Enum)
 
 
-class EnumerationMother(Generic[E]):
+class EnumerationMother(ABC, Generic[E]):
     """
     EnumerationMother class is responsible for creating random enum values.
 
@@ -33,7 +41,11 @@ class ColorEnumeration(Enum):
         BLUE = 3
 
 
-    color_mother = EnumerationMother(enumeration=ColorEnumeration)
+    class ColorMother(EnumerationMother[ColorEnumeration]):
+        pass
+
+
+    color_mother = ColorMother()
 
     color = color_mother.create()
     print(color)
@@ -43,43 +55,34 @@ class ColorEnumeration(Enum):
 
     _enumeration: type[E]
 
-    def __init__(self, *, enumeration: type[E]) -> None:
+    @override
+    def __init_subclass__(cls, **kwargs: Any) -> None:
         """
-        Initialize the EnumerationMother with the specified enumeration class `enumeration`.
+        Initializes the class.
 
         Args:
-            enumeration (type[E]): The enumeration class to generate values from.
+            **kwargs (Any): Keyword arguments.
 
         Raises:
-            TypeError: If the provided `enumeration` is not a subclass of Enum.
-
-        Example:
-        ```python
-        from enum import Enum, unique
-
-        from object_mother_pattern.mothers import EnumerationMother
-
-
-        @unique
-        class ColorEnumeration(Enum):
-            RED = 1
-            GREEN = 2
-            BLUE = 3
+            TypeError: If the class parameter is not an Enum subclass.
+            TypeError: If the class is not parameterized.
+        """
+        super().__init_subclass__(**kwargs)
 
+        for base in getattr(cls, '__orig_bases__', ()):
+            if get_origin(tp=base) is EnumerationMother:
+                enumeration, *_ = get_args(tp=base)
 
-        color_mother = EnumerationMother(enumeration=ColorEnumeration)
+                if not (isclass(object=enumeration) and issubclass(enumeration, Enum)):
+                    raise TypeError(f'EnumerationMother[...] <<<{enumeration}>>> must be an Enum subclass. Got <<<{type(enumeration).__name__}>>> type.')  # noqa: E501  # fmt: skip
 
-        color = color_mother.create()
-        print(color)
-        # >>> Color.GREEN
-        ```
-        """
-        if type(enumeration) is not type(Enum):
-            raise TypeError('EnumerationMother enumeration must be a subclass of Enum.')
+                cls._enumeration = enumeration
+                return
 
-        self._enumeration = enumeration
+        raise TypeError('EnumerationMother must be parameterized, e.g. "class ColorMother(EnumerationMother[ColorEnumeration])".')  # noqa: E501  # fmt: skip
 
-    def create(self, *, value: E | None = None) -> E:
+    @classmethod
+    def create(cls, *, value: E | None = None) -> E:
         """
         Create a random enumeration value from the enumeration class. If a specific
         value is provided, it is returned after ensuring it is a member of the enumeration.
@@ -107,20 +110,24 @@ class ColorEnumeration(Enum):
             BLUE = 3
 
 
-        color_mother = EnumerationMother(enumeration=ColorEnumeration)
+        class ColorMother(EnumerationMother[ColorEnumeration]):
+            pass
+
+
+        color_mother = ColorMother()
 
         color = color_mother.create()
         print(color)
         # >>> Color.GREEN
         ```
         """
         if value is not None:
-            if type(value) is not self._enumeration:
-                raise TypeError(f'{self._enumeration.__name__}Mother value must be an instance of {self._enumeration.__name__}.')  # noqa: E501  # fmt: skip
+            if not isinstance(value, cls._enumeration):
+                raise TypeError(f'{cls._enumeration.__name__}Mother value must be an instance of <<<{cls._enumeration.__name__}>>> type.')  # noqa: E501  # fmt: skip
 
-            return value
+            return value  # type: ignore[no-any-return]
 
-        return choice(seq=tuple(self._enumeration))  # noqa: S311
+        return choice(seq=tuple(cls._enumeration))  # type: ignore[arg-type]  # noqa: S311
 
     @staticmethod
     def invalid_type(remove_types: Iterable[type[Any]] | None = None) -> Any:  # noqa: C901

tests/mothers/test_enumeration_mother.py

@@ -3,6 +3,7 @@
 """
 
 from enum import Enum, auto, unique
+from re import escape
 
 from pytest import mark, raises as assert_raises
 
@@ -20,37 +21,68 @@ class _TestEnum(Enum):
     VALUE_3 = auto()
 
 
+class TestEnumMother(EnumerationMother[_TestEnum]):
+    """
+    TestEnumMother class.
+    """
+
+
 @mark.unit_testing
-def test_enumeration_mother_happy_path() -> None:
+def test_enumeration_mother_can_be_instantiated() -> None:
     """
-    Test EnumerationMother happy path.
+    Test EnumerationMother can be instantiated.
     """
-    mother = EnumerationMother(enumeration=_TestEnum)
+    EnumerationMother()
+
+
+@mark.unit_testing
+def test_enumeration_mother_init_with_invalid_type() -> None:
+    """
+    Test EnumerationMother initialization with invalid type.
+    """
+    value = EnumerationMother.invalid_type(remove_types=(list, set, tuple, dict))
+
+    with assert_raises(
+        expected_exception=TypeError,
+        match=r'EnumerationMother\[.*\] <<<.*>>> must be an Enum subclass. Got <<<.*>>> type.',
+    ):
 
-    assert mother.create() in list(_TestEnum)
+        class BooleanMother(EnumerationMother[value]):  # type: ignore[valid-type]
+            pass
 
 
 @mark.unit_testing
-def test_enumeration_mother_init_invalid_enumeration_type() -> None:
+def test_enumeration_mother_init_without_parameterization() -> None:
     """
-    Test EnumerationMother initialization with invalid enumeration type.
+    Test EnumerationMother initialization without parameterization.
     """
     with assert_raises(
         expected_exception=TypeError,
-        match='EnumerationMother enumeration must be a subclass of Enum.',
+        match=escape(
+            pattern='EnumerationMother must be parameterized, e.g. "class ColorMother(EnumerationMother[ColorEnumeration])".'  # noqa: E501
+        ),
     ):
-        EnumerationMother(enumeration=EnumerationMother.invalid_type())
+
+        class ColorMother(EnumerationMother):  # type: ignore[type-arg]
+            pass
+
+
+@mark.unit_testing
+def test_enumeration_mother_happy_path() -> None:
+    """
+    Test EnumerationMother happy path.
+    """
+    assert TestEnumMother().create() in tuple(_TestEnum)
 
 
 @mark.unit_testing
 def test_enumeration_mother_create_with_value() -> None:
     """
     Test EnumerationMother create method with specific value.
     """
-    mother = EnumerationMother(enumeration=_TestEnum)
     expected_value = _TestEnum.VALUE_1
 
-    result = mother.create(value=expected_value)
+    result = TestEnumMother.create(value=expected_value)
 
     assert result == expected_value
 
@@ -60,13 +92,11 @@ def test_enumeration_mother_create_with_invalid_value_type() -> None:
     """
     Test EnumerationMother create method with invalid value type.
     """
-    mother = EnumerationMother(enumeration=_TestEnum)
-
     with assert_raises(
         expected_exception=TypeError,
-        match='_TestEnumMother value must be an instance of _TestEnum.',
+        match=r'_TestEnumMother value must be an instance of <<<.*>>> type.',
     ):
-        mother.create(value=EnumerationMother.invalid_type())
+        TestEnumMother.create(value=EnumerationMother.invalid_type())
 
 
 @mark.unit_testing