add factory pattern to python patterns plus associated tests

Author: Wael Jabeur

python/src/creational/factory/__init__.py

@@ -0,0 +1,4 @@
+from .factory import Factory
+from .product_type import ProductType
+
+__all__ = ["Factory", "ProductType"]

python/src/creational/factory/factory.py

@@ -0,0 +1,50 @@
+from .product import Product, ConcreteProductA, ConcreteProductB
+from .product_type import ProductType
+
+
+class Factory:
+    """
+    Factory: Provides a method to create objects without
+    specifying the exact class.
+    """
+
+    @staticmethod
+    def create_product(product_type: ProductType) -> Product:
+        """
+        Factory Method: Returns an instance of a
+        product based on the provided type.
+        """
+        if product_type == ProductType.PRODUCT_A:
+            return ConcreteProductA()
+        elif product_type == ProductType.PRODUCT_B:
+            return ConcreteProductB()
+        else:
+            raise ValueError(f"Unknown product type: {product_type}")
+
+# Example Usage:
+#
+# from src.creational.factory.factory import Factory
+# from src.creational.factory.product_type import ProductType
+#
+# product_a = Factory.create_product(ProductType.PRODUCT_A)
+# print(product_a.operation())  # Output: "ConcreteProductA operation executed"
+#
+# product_b = Factory.create_product(ProductType.PRODUCT_B)
+# print(product_b.operation())  # Output: "ConcreteProductB operation executed"
+#
+# Common Mistakes to Avoid:
+#
+# 1. Hardcoding Class Names in Factory:
+#    - Mistake: Using raw strings to determine product types.
+#    - Fix: Use enums (`ProductType`) to avoid typos and
+#    improve maintainability.
+#
+# 2. Allowing Factory to Grow Uncontrollably:
+#    - Mistake: Adding too many `if-elif` conditions inside the factory.
+#    - Fix: Use a registry pattern if new products need
+#    to be added dynamically.
+#
+# 3. Misusing the Factory for Simple Object Creation:
+#    - Mistake: Using the factory when simple instantiation
+#    (`ConcreteProductA()`) is sufficient.
+#    - Fix: Use Factory only when object creation logic is complex or varies.

python/src/creational/factory/product.py

@@ -0,0 +1,32 @@
+from abc import ABC, abstractmethod
+
+
+class Product(ABC):
+    """
+    Abstract Product: Defines an interface that concrete products must implement.
+    """
+
+    @abstractmethod
+    def operation(self) -> str:
+        """
+        Abstract method to be implemented by concrete products.
+        """
+        pass
+
+
+class ConcreteProductA(Product):
+    """
+    Concrete Product A: Implements the Product interface.
+    """
+
+    def operation(self) -> str:
+        return "ConcreteProductA operation executed"
+
+
+class ConcreteProductB(Product):
+    """
+    Concrete Product B: Implements the Product interface.
+    """
+
+    def operation(self) -> str:
+        return "ConcreteProductB operation executed"

python/src/creational/factory/product_type.py

@@ -0,0 +1,11 @@
+# src/creational/factory/product_type.py
+
+from enum import Enum
+
+
+class ProductType(Enum):
+    """
+    Enum for different product types.
+    """
+    PRODUCT_A = "product_a"
+    PRODUCT_B = "product_b"

python/tests/creational/factory/__init__.py

@@ -0,0 +1,4 @@
+
+"""
+Tests for the Factory pattern.
+"""

python/tests/creational/factory/test_factory.py

@@ -0,0 +1,35 @@
+import pytest
+from src.creational.factory.factory import Factory
+from src.creational.factory.product import ConcreteProductA, ConcreteProductB, Product
+from src.creational.factory.product_type import ProductType
+
+
+def test_factory_create_product_a():
+    """
+    Test that Factory correctly creates ConcreteProductA.
+    """
+    product = Factory.create_product(ProductType.PRODUCT_A)
+    assert isinstance(product, ConcreteProductA)
+    # Ensures it follows the Product interface
+    assert isinstance(product, Product)
+    assert product.operation() == "ConcreteProductA operation executed"
+
+
+def test_factory_create_product_b():
+    """
+    Test that Factory correctly creates ConcreteProductB.
+    """
+    product = Factory.create_product(ProductType.PRODUCT_B)
+    assert isinstance(product, ConcreteProductB)
+    # Ensures it follows the Product interface
+    assert isinstance(product, Product)
+    assert product.operation() == "ConcreteProductB operation executed"
+
+
+def test_factory_invalid_product():
+    """
+    Test that Factory raises an error when given an invalid ProductType.
+    """
+    with pytest.raises(ValueError, match="Unknown product type"):
+        # Should raise ValueError
+        Factory.create_product("invalid_product")

python/tests/creational/factory/test_product.py

@@ -0,0 +1,22 @@
+import pytest
+from src.creational.factory.product import ConcreteProductA, ConcreteProductB, Product
+
+
+def test_concrete_product_a():
+    """
+    Test that ConcreteProductA executes the correct operation.
+    """
+    product = ConcreteProductA()
+    # Ensure it implements the abstract Product class
+    assert isinstance(product, Product)
+    assert product.operation() == "ConcreteProductA operation executed"
+
+
+def test_concrete_product_b():
+    """
+    Test that ConcreteProductB executes the correct operation.
+    """
+    product = ConcreteProductB()
+    # Ensure it implements the abstract Product class
+    assert isinstance(product, Product)
+    assert product.operation() == "ConcreteProductB operation executed"

python/tests/creational/factory/test_product_type.py

@@ -0,0 +1,16 @@
+from src.creational.factory.product_type import ProductType
+
+
+def test_enum_values():
+    """
+    Test that the ProductType enum contains the correct values.
+    """
+    assert ProductType.PRODUCT_A.value == "product_a"
+    assert ProductType.PRODUCT_B.value == "product_b"
+
+
+def test_enum_members():
+    """
+    Test that the ProductType enum contains the correct members.
+    """
+    assert list(ProductType) == [ProductType.PRODUCT_A, ProductType.PRODUCT_B]