🧪 tests: update testcase for making coverage.

Author: korawica

src/ddeutil/workflow/job.py

@@ -1273,7 +1273,6 @@ def local_execute(
 
         errors: DictData = {}
         statuses: list[Status] = [WAIT] * len_strategy
-        fail_fast: bool = False
 
         if not job.strategy.fail_fast:
             done: Iterator[Future] = as_completed(futures)
@@ -1298,7 +1297,6 @@ def local_execute(
                 )
                 trace.debug(f"[JOB]: ... Job was set Fail-Fast{nd}")
                 done: Iterator[Future] = as_completed(futures)
-                fail_fast: bool = True
 
         for i, future in enumerate(done, start=0):
             try:
@@ -1313,19 +1311,10 @@ def local_execute(
                 pass
 
     status: Status = validate_statuses(statuses)
-
-    # NOTE: Prepare status because it does not cancel from parent event but
-    #   cancel from failed item execution.
-    if fail_fast and status == CANCEL:
-        status = FAILED
-
-    return Result(
-        run_id=run_id,
-        parent_run_id=parent_run_id,
+    return Result.from_trace(trace).catch(
         status=status,
         context=catch(context, status=status, updated=errors),
         info={"execution_time": time.monotonic() - ts},
-        extras=job.extras,
     )
 
 

src/ddeutil/workflow/result.py

@@ -8,20 +8,12 @@
 This module provides the core result and status management functionality for
 workflow execution tracking. It includes the Status enumeration for execution
 states and the Result dataclass for context transfer between workflow components.
-
-Classes:
-    Status: Enumeration for execution status tracking
-    Result: Dataclass for execution context and result management
-
-Functions:
-    validate_statuses: Determine final status from multiple status values
-    get_status_from_error: Convert exception types to appropriate status
 """
 from __future__ import annotations
 
 from dataclasses import field
 from enum import Enum
-from typing import Optional, TypedDict, Union
+from typing import Any, Optional, TypedDict, Union
 
 from pydantic import ConfigDict
 from pydantic.dataclasses import dataclass
@@ -327,16 +319,26 @@ def get_context_by_layer(
     key: str,
     layer: Layer,
     context_key: str,
-):
+    *,
+    default: Optional[Any] = None,
+) -> Any:  # pragma: no cov
     if layer == Layer.WORKFLOW:
-        return context.get("jobs", {}).get(key, {}).get(context_key, WAIT)
+        return context.get("jobs", {}).get(key, {}).get(context_key, default)
     elif layer == Layer.JOB:
-        return context.get("stages", {}).get(key, {}).get(context_key, WAIT)
+        return context.get("stages", {}).get(key, {}).get(context_key, default)
     elif layer == Layer.STRATEGY:
-        return context.get("strategies", {}).get(key, {}).get(context_key, WAIT)
-    return context.get(key, {}).get(context_key, WAIT)
+        return (
+            context.get("strategies", {}).get(key, {}).get(context_key, default)
+        )
+    return context.get(key, {}).get(context_key, default)
 
 
-def get_status(context: DictData, key: str, layer: Layer):
+def get_status(
+    context: DictData,
+    key: str,
+    layer: Layer,
+) -> Status:  # pragma: no cov
     """Get status from context by a specific key and context layer."""
-    return get_context_by_layer(context, key, layer, context_key="status")
+    return get_context_by_layer(
+        context, key, layer, context_key="status", default=WAIT
+    )

src/ddeutil/workflow/stages.py

@@ -587,7 +587,7 @@ def is_nested(self) -> bool:
         """
         return False
 
-    def detail(self) -> DictData:
+    def detail(self) -> DictData:  # pragma: no cov
         """Return the detail of this stage for generate markdown.
 
         Returns:
@@ -3115,8 +3115,24 @@ class CaseStage(BaseNestedStage):
     def __validate_match(
         cls, match: list[Union[Match, Else]]
     ) -> list[Union[Match, Else]]:
-        if len([m for m in match if isinstance(m, Else)]) > 1:
-            raise ValueError("match field should contain only one Else model")
+        """Validate the match field should contain only one Else model."""
+        c_else_case: int = 0
+        c_else_model: int = 0
+        for m in match:
+            if isinstance(m, Else):
+                if c_else_model:
+                    raise ValueError(
+                        "Match field should contain only one `Else` model."
+                    )
+                c_else_model += 1
+                continue
+            if isinstance(m, Match) and m.case == "_":
+                if c_else_case:
+                    raise ValueError(
+                        "Match field should contain only one else, '_', case."
+                    )
+                c_else_case += 1
+                continue
         return match
 
     def extract_stages_from_case(

tests/stages/test_stage_case.py

@@ -1,9 +1,71 @@
+import pytest
 from ddeutil.workflow import CANCEL, FAILED, SKIP, SUCCESS, Result
 from ddeutil.workflow.stages import CaseStage, Stage
+from pydantic import ValidationError
 
 from ..utils import MockEvent
 
 
+def test_case_stage_raise():
+    # NOTE: Raise because it contains else case more than 1.
+    with pytest.raises(ValidationError):
+        CaseStage.model_validate(
+            {
+                "name": "Start run case-match stage",
+                "id": "case-stage",
+                "case": "${{ params.name }}",
+                "match": [
+                    {
+                        "else": [
+                            {
+                                "name": "Else stage",
+                                "echo": "Not match any case.",
+                            },
+                        ],
+                    },
+                    {
+                        "else": [
+                            {
+                                "name": "Else stage",
+                                "echo": "Not match any case.",
+                            },
+                        ],
+                    },
+                ],
+            }
+        )
+
+    # NOTE: Raise because it contains else case more than 1.
+    with pytest.raises(ValidationError):
+        CaseStage.model_validate(
+            {
+                "name": "Start run case-match stage",
+                "id": "case-stage",
+                "case": "${{ params.name }}",
+                "match": [
+                    {
+                        "case": "_",
+                        "stages": [
+                            {
+                                "name": "Else stage",
+                                "echo": "Not match any case.",
+                            },
+                        ],
+                    },
+                    {
+                        "case": "_",
+                        "stages": [
+                            {
+                                "name": "Else stage",
+                                "echo": "Not match any case.",
+                            },
+                        ],
+                    },
+                ],
+            }
+        )
+
+
 def test_case_stage_exec():
     stage: Stage = CaseStage.model_validate(
         {
@@ -225,7 +287,7 @@ def test_case_stage_exec_cancel():
         "status": CANCEL,
         "errors": {
             "name": "StageCancelError",
-            "message": ("Cancel before start case process."),
+            "message": "Cancel before start case process.",
         },
     }
 
@@ -244,6 +306,30 @@ def test_case_stage_exec_cancel():
         },
     }
 
+    event = MockEvent(n=2)
+    rs: Result = stage.execute(
+        {"params": {"name": "bar"}}, event=event, run_id="04"
+    )
+    assert rs.status == CANCEL
+    assert rs.context == {
+        "status": CANCEL,
+        "case": "bar",
+        "stages": {
+            "3616274431": {
+                "outputs": {},
+                "errors": {
+                    "name": "StageCancelError",
+                    "message": "Cancel before start empty process.",
+                },
+                "status": CANCEL,
+            }
+        },
+        "errors": {
+            "name": "StageCancelError",
+            "message": "Cancel case 'bar' after end nested process.",
+        },
+    }
+
 
 def test_case_stage_exec_skipped():
     stage: Stage = CaseStage.model_validate(
@@ -268,3 +354,30 @@ def test_case_stage_exec_skipped():
     rs: Result = stage.execute({"params": {"name": "test"}}, run_id="01")
     assert rs.status == SKIP
     assert rs.context == {"status": SKIP}
+
+    stage: Stage = CaseStage.model_validate(
+        {
+            "name": "Stage skip not has else condition",
+            "id": "not-else",
+            "case": "${{ params.name }}",
+            "match": [
+                {
+                    "case": "bar",
+                    "stages": [
+                        {
+                            "name": "Match name with Bar",
+                            "if": "'${{ params.name }}' != 'bar'",
+                            "echo": "Hello ${{ params.name }}",
+                        }
+                    ],
+                }
+            ],
+        }
+    )
+    rs: Result = stage.execute({"params": {"name": "bar"}}, run_id="02")
+    assert rs.status == SKIP
+    assert rs.context == {
+        "status": SKIP,
+        "case": "bar",
+        "stages": {"3616274431": {"outputs": {}, "status": SKIP}},
+    }