🧪 tests: update testcase for make coverage on stages module.

Author: korawica

src/ddeutil/workflow/audits.py

@@ -26,14 +26,11 @@
     get_audit_model: Factory function for creating audit instances
 
 Example:
-    ```python
-    from ddeutil.workflow.audits import get_audit_model
 
-    # Create file-based Audit
-    audit = get_audit_model(run_id="run-123")
-    audit.info("Workflow execution started")
-    audit.success("Workflow completed successfully")
-    ```
+    >>> from ddeutil.workflow.audits import get_audit_model
+    >>> audit = get_audit_model(run_id="run-123")
+    >>> audit.info("Workflow execution started")
+    >>> audit.success("Workflow completed successfully")
 
 Note:
     Audit instances are automatically configured based on the workflow
@@ -228,7 +225,8 @@ def save(
         """
         raise NotImplementedError("Audit should implement `save` method.")
 
-    def compress_data(self, data: str) -> bytes:
+    @staticmethod
+    def compress_data(data: str) -> bytes:
         """Compress audit data for storage efficiency.
 
         Args:
@@ -239,7 +237,8 @@ def compress_data(self, data: str) -> bytes:
         """
         return zlib.compress(data.encode("utf-8"))
 
-    def decompress_data(self, data: bytes) -> str:
+    @staticmethod
+    def decompress_data(data: bytes) -> str:
         """Decompress audit data.
 
         Args:
@@ -493,7 +492,7 @@ def cleanup_old_audits(self, max_age_days: int = 30) -> int:
         return cleaned_count
 
 
-class SQLiteAudit(BaseAudit):
+class SQLiteAudit(BaseAudit):  # pragma: no cov
     """SQLite Audit model for database-based audit storage.
 
     This class inherits from BaseAudit and implements SQLite database storage

tests/stages/test_stage_case.py

@@ -36,7 +36,7 @@ def test_case_stage_exec(test_path):
                     ],
                 },
             ],
-        }
+        },
     )
     rs: Result = stage.execute({"params": {"name": "bar"}})
     assert rs.status == SUCCESS
@@ -110,6 +110,7 @@ def test_case_stage_exec_raise():
                     ],
                 },
             ],
+            "extras": {"foo": "bar"},
         }
     )
     # NOTE: Raise because else condition does not set.
@@ -125,6 +126,43 @@ def test_case_stage_exec_raise():
         },
     }
 
+    stage: Stage = CaseStage.model_validate(
+        {
+            "name": "Stage raise not has else condition",
+            "id": "raise-else",
+            "case": "${{ params.name }}",
+            "match": [
+                {
+                    "case": "bar",
+                    "stages": [
+                        {
+                            "name": "Raise stage",
+                            "raise": "Raise with ${{ params.name }}",
+                        }
+                    ],
+                },
+            ],
+            "extras": {"foo": "bar"},
+        }
+    )
+    rs: Result = stage.execute({"params": {"name": "bar"}})
+    assert rs.status == FAILED
+    assert rs.context == {
+        "status": FAILED,
+        "case": "bar",
+        "stages": {
+            "4045646338": {
+                "outputs": {},
+                "errors": {"name": "StageError", "message": "Raise with bar"},
+                "status": FAILED,
+            }
+        },
+        "errors": {
+            "name": "StageError",
+            "message": "Case-Stage was break because it has a sub stage, Raise stage, failed without raise error.",
+        },
+    }
+
 
 def test_case_stage_exec_cancel():
     stage: Stage = CaseStage.model_validate(
@@ -158,6 +196,19 @@ def test_case_stage_exec_cancel():
         },
     }
 
+    event = MockEvent(n=1)
+    rs: Result = stage.execute({"params": {"name": "bar"}}, event=event)
+    assert rs.status == CANCEL
+    assert rs.context == {
+        "status": CANCEL,
+        "case": "bar",
+        "stages": {},
+        "errors": {
+            "name": "StageError",
+            "message": "Case-Stage was canceled from event that had set before stage case execution.",
+        },
+    }
+
 
 def test_case_stage_exec_skipped():
     stage: Stage = CaseStage.model_validate(

tests/stages/test_stage_until.py

@@ -9,7 +9,7 @@
     Stage,
     Workflow,
 )
-from ddeutil.workflow.stages import EmptyStage, UntilStage
+from ddeutil.workflow.stages import EmptyStage, RaiseStage, UntilStage
 
 from ..utils import MockEvent, dump_yaml_context
 
@@ -50,6 +50,81 @@ def test_until_stage():
     }
 
 
+def test_until_stage_raise():
+    stage = UntilStage.model_validate(
+        {
+            "name": "This is until stage",
+            "item": 1,
+            "until": "${{ item }} > 2",
+            "stages": [
+                RaiseStage.model_validate(
+                    {"name": "Raise stage nested", "raise": "Raise some error."}
+                ),
+            ],
+            "extras": {"foo": "bar"},
+        }
+    )
+    rs: Result = stage.execute(params={})
+    assert rs.status == FAILED
+    assert rs.context == {
+        "status": FAILED,
+        "until": {
+            1: {
+                "status": FAILED,
+                "loop": 1,
+                "item": 1,
+                "stages": {
+                    "1426584094": {
+                        "outputs": {},
+                        "errors": {
+                            "name": "StageError",
+                            "message": "Raise some error.",
+                        },
+                        "status": FAILED,
+                    }
+                },
+                "errors": {
+                    "name": "StageError",
+                    "message": "Loop execution was break because its nested-stage, 'Raise stage nested', failed.",
+                },
+            }
+        },
+        "errors": {
+            "name": "StageError",
+            "message": "Loop execution was break because its nested-stage, 'Raise stage nested', failed.",
+        },
+    }
+
+    stage = UntilStage.model_validate(
+        {
+            "name": "This is until stage",
+            "item": 1,
+            "until": "${{ item }} if ${{ item }} == 1 else 'demo'",
+            "stages": [
+                EmptyStage(name="Empty stage nested", echo="1"),
+            ],
+            "extras": {"foo": "bar"},
+        }
+    )
+    rs: Result = stage.execute(params={})
+    assert rs.status == FAILED
+    assert rs.context == {
+        "status": FAILED,
+        "until": {
+            1: {
+                "status": SUCCESS,
+                "loop": 1,
+                "item": 1,
+                "stages": {"4735427693": {"outputs": {}, "status": SUCCESS}},
+            }
+        },
+        "errors": {
+            "name": "TypeError",
+            "message": "Return type of until condition not be `boolean`, getting: 'demo'",
+        },
+    }
+
+
 def test_until_stage_skipped():
     stage = UntilStage.model_validate(
         {
@@ -89,8 +164,6 @@ def test_until_stage_skipped():
 
 
 def test_until_stage_cancel():
-    event = Event()
-    event.set()
     stage = UntilStage.model_validate(
         {
             "name": "This is until stage",
@@ -103,6 +176,8 @@ def test_until_stage_cancel():
             "extras": {"foo": "bar"},
         }
     )
+    event = Event()
+    event.set()
     rs: Result = stage.execute(params={}, event=event)
     assert rs.status == CANCEL
     assert rs.context == {
@@ -137,6 +212,38 @@ def test_until_stage_cancel():
         },
     }
 
+    event = MockEvent(n=2)
+    rs: Result = stage.execute(params={}, event=event)
+    assert rs.status == CANCEL
+    assert rs.context == {
+        "status": CANCEL,
+        "until": {
+            1: {
+                "status": CANCEL,
+                "loop": 1,
+                "item": 1,
+                "stages": {
+                    "4735427693": {
+                        "outputs": {},
+                        "errors": {
+                            "name": "StageCancelError",
+                            "message": "Execution was canceled from the event before start parallel.",
+                        },
+                        "status": CANCEL,
+                    }
+                },
+                "errors": {
+                    "name": "StageCancelError",
+                    "message": "Loop execution was canceled from the event after end loop execution.",
+                },
+            }
+        },
+        "errors": {
+            "name": "StageCancelError",
+            "message": "Loop execution was canceled from the event after end loop execution.",
+        },
+    }
+
 
 def test_until_stage_exec_exceed_loop():
     stage = UntilStage.model_validate(

tests/test_audits.py

@@ -3,8 +3,34 @@
 from unittest import mock
 
 import pytest
-from ddeutil.workflow.audits import FileAudit
+from ddeutil.workflow.audits import BaseAudit, FileAudit
 from ddeutil.workflow.conf import Config
+from pydantic import ValidationError
+
+
+@mock.patch.multiple(BaseAudit, __abstractmethods__=set())
+def test_base_audit():
+    audit = BaseAudit.model_validate(
+        {
+            "name": "wf-scheduling",
+            "type": "manual",
+            "release": datetime(2024, 1, 1, 1),
+            "run_id": "558851633820240817184358131811",
+        }
+    )
+    cp_data = audit.compress_data("foo")
+    assert audit.decompress_data(cp_data) == "foo"
+
+    with pytest.raises(ValidationError):
+        BaseAudit.model_validate(
+            {
+                "name": "wf-scheduling",
+                "type": "manual",
+                "release": datetime(2024, 1, 1, 1),
+                "run_id": "558851633820240817184358131811",
+                "extras": "foo",
+            }
+        )
 
 
 @mock.patch.object(Config, "enable_write_audit", False)
@@ -20,6 +46,7 @@ def test_conf_log_file():
             "parent_run_id": None,
             "run_id": "558851633820240817184358131811",
             "update": datetime.now(),
+            "extras": None,
         },
     )
     log.save(excluded=None)