Process as subprocess conditions (tests + doc) (#27)

* add: condition tests
update: pyproject.toml
del: attrs from requirements_dev.txt
* add: example with conditions
add: test for the process with conditions
* update: doc

---------

Co-authored-by: Sergei Aleshin <sergei.aleshin@alludo.com>

Author: s-aleshin

README.md

@@ -18,9 +18,13 @@ pip install logic-processes-layer
 
 ## New Features
 
-- ProcessAsSubprocess: Use any process as a subprocess.
-- InitMapper: Simplifies process initialization with attribute mapping from the context.
-- ProcessAttr: Retrieve attributes from the process context or directly from the process.
+- **ProcessAsSubprocess**: Use any process as a subprocess.
+- **InitMapper**: Simplifies process initialization with attribute mapping from the context.
+- **ProcessAttr**: Retrieve attributes from the process context or directly from the process.
+- **Conditions Support**: Add logical conditions to control the execution of processes.
+  - **AttrCondition**: Define conditions based on attributes of the process or context.
+  - **FunctionCondition**: Wrap custom functions as conditions.
+  - **Logical Operators**: Combine conditions with `&` (AND), `|` (OR), `~` (NOT), and `^` (XOR) for advanced logic.
 - [Examples](tests/examples) of how to use the logic_processes_layer package.
 
 

pyproject.toml

@@ -8,7 +8,6 @@ version = "1.2025.01.06"
 requires-python = ">=3.8"
 description = "Abstractions for create business logic"
 readme = "README.md"
-dependencies = ["attrs~=24.3"]
 authors = [{ name = "Sergei (Gefest) Romanchuk", email = "pod.cargoes.0u@icloud.com" }]
 
 license = { file = "LICENSE" }
@@ -31,4 +30,5 @@ ignore = [
 
 per-file-ignores = [
     "__init__.py:WPS347, WPS440",
-    "*_enums.py:WPS115",]
+    "*_enums.py:WPS115",
+    "tests/test_*.py:WPS202, WPS442",]

tests/examples/processors/process_with_conditions.py

@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+import dataclasses
+
+from logic_processes_layer import BaseProcessor
+from logic_processes_layer.extensions import InitMapper, ProcessAsSubprocess, ProcessAttr
+from logic_processes_layer.extensions.conditions import AttrCondition, FunctionCondition
+
+
+_ONE_H = 100
+
+
+@dataclasses.dataclass
+class NotifyClientProcess(BaseProcessor):
+    notification_message: str
+
+    def run(self): ...  # noqa: WPS428
+
+
+_order_is_completed_condition: AttrCondition = AttrCondition(ProcessAttr("is_completed"))
+_order_amount_condition: FunctionCondition = FunctionCondition(lambda context: context.process.order_amount > _ONE_H)
+_client_agreed_condition: AttrCondition = AttrCondition(ProcessAttr("client_agreed_to_notifications"))
+_combined_condition = _order_is_completed_condition & (_order_amount_condition | _client_agreed_condition)
+
+_notify_client_process = ProcessAsSubprocess(
+    process_cls=NotifyClientProcess,
+    init_mapper=InitMapper(notification_message=ProcessAttr("notification_message")),
+    conditions=(_combined_condition,),
+)
+
+
+@dataclasses.dataclass
+class OrderStatusProcess(BaseProcessor):
+    is_completed: bool
+    client_agreed_to_notifications: bool
+    order_amount: float
+    notification_message: str = dataclasses.field(init=False, default="Order completed successfully!")
+
+    post_run = (_notify_client_process,)
+
+    def run(self): ...  # noqa: WPS428

tests/test_conditions.py

@@ -0,0 +1,102 @@
+from __future__ import annotations
+
+from unittest.mock import Mock
+
+import pytest
+
+from logic_processes_layer.extensions import ProcessAttr
+from logic_processes_layer.extensions.conditions import AttrCondition, FunctionCondition
+
+
+_TWO = 2
+
+
+@pytest.fixture
+def mock_process_attr():
+    return Mock(spec=ProcessAttr)
+
+
+@pytest.fixture
+def mock_context():
+    return Mock()
+
+
+@pytest.fixture
+def attr_condition(mock_process_attr):
+    return AttrCondition(mock_process_attr)
+
+
+def test_attr_condition_positive(attr_condition, mock_process_attr, mock_context):
+    mock_process_attr.get_value.return_value = True
+    assert attr_condition(mock_context) is True
+    mock_process_attr.get_value.assert_called_once_with(mock_context)
+
+
+def test_attr_condition_negative(attr_condition, mock_process_attr, mock_context):
+    mock_process_attr.get_value.return_value = False
+    assert attr_condition(mock_context) is False
+    mock_process_attr.get_value.assert_called_once_with(mock_context)
+
+
+def test_attr_condition_negated(attr_condition, mock_process_attr, mock_context):
+    mock_process_attr.get_value.return_value = True
+    condition = ~attr_condition
+
+    assert condition(mock_context) is False
+    mock_process_attr.get_value.assert_called_once_with(mock_context)
+
+
+def test_function_condition_positive(mock_context):
+    mock_func = Mock(return_value=True)
+    condition: FunctionCondition = FunctionCondition(mock_func)
+
+    assert condition(mock_context) is True
+    mock_func.assert_called_once_with(mock_context)
+
+
+def test_function_condition_negative(mock_context):
+    mock_func = Mock(return_value=False)
+    condition: FunctionCondition = FunctionCondition(mock_func)
+
+    assert condition(mock_context) is False
+    mock_func.assert_called_once_with(mock_context)
+
+
+def test_function_condition_negated(mock_context):
+    mock_func = Mock(return_value=True)
+    condition = ~FunctionCondition(mock_func)
+
+    assert condition(mock_context) is False
+    mock_func.assert_called_once_with(mock_context)
+
+
+def test_operator_condition_and(attr_condition, mock_process_attr, mock_context):
+    mock_process_attr.get_value.side_effect = (True, True)
+    condition1 = attr_condition
+    condition2 = attr_condition
+    combined_condition = condition1 & condition2
+
+    assert combined_condition(mock_context) is True
+    assert mock_process_attr.get_value.call_count == _TWO
+
+
+def test_operator_condition_or(attr_condition, mock_process_attr, mock_context):
+    mock_process_attr.get_value.side_effect = (False, True)
+    condition1 = attr_condition
+    condition2 = attr_condition
+    combined_condition = condition1 | condition2
+
+    assert combined_condition(mock_context) is True
+    assert mock_process_attr.get_value.call_count == _TWO
+
+
+def test_operator_condition_complex(attr_condition, mock_process_attr, mock_context):
+    mock_process_attr.get_value.side_effect = (True, False, True)
+    condition1 = attr_condition
+    condition2 = ~attr_condition
+    condition3 = attr_condition
+    condition4: FunctionCondition = FunctionCondition(lambda _: True)
+    combined_condition = condition1 & (condition2 | condition3) & condition4
+
+    assert combined_condition(mock_context) is True
+    assert mock_process_attr.get_value.call_count == _TWO

tests/test_process_with_conditions.py

@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+from unittest.mock import patch
+
+import pytest
+
+from .examples.processors.process_with_conditions import NotifyClientProcess, OrderStatusProcess
+
+
+@pytest.mark.parametrize(
+    argnames="is_completed, client_agreed, order_amount, should_notify",
+    argvalues=(
+        (True, True, 150, True),
+        (True, False, 150, True),
+        (True, True, 50, True),
+        (True, False, 50, False),
+        (False, True, 150, False),
+        (False, False, 150, False),
+    ),
+    ids=(
+        "Both completed and delayed, amount > 100 -> Notify",
+        "Completed but not delayed, amount > 100 -> Notify",
+        "Both completed and delayed, amount <= 100 -> No Notify",
+        "Completed but not delayed, amount <= 100 -> No Notify",
+        "Not completed, delayed, amount > 100 -> No Notify",
+        "Not completed, not delayed, amount > 100 -> No Notify",
+    ),
+)
+def test_order_status_process(is_completed, client_agreed, order_amount, should_notify):
+    with patch.object(NotifyClientProcess, "run", return_value=None) as mock_notify_run:
+        process = OrderStatusProcess(
+            is_completed=is_completed,
+            client_agreed_to_notifications=client_agreed,
+            order_amount=order_amount,
+        )
+        process()
+
+        if should_notify:
+            mock_notify_run.assert_called_once()
+        else:
+            mock_notify_run.assert_not_called()