openforce/tests/phase4/test_sprint42_flow_engine.py
Goose eaaf3f2791 test(phase4): add Sprint 4.1/4.2/4.3 QA gate stubs
Contract tests for:
- 4.1: entity_name/custom_object mutual exclusion, GIN index in migration,
       additionalProperties validation on standard objects, custom field
       transfer during lead conversion
- 4.2: DecisionNode first-match determinism, SubflowNode depth limit (10),
       LoopNode cycle detection, AssignmentNode operators
- 4.3: post_save dispatch, / context, re-entrancy
       guard, Celery Beat idempotency

All tests will fail until Sprint 4.x code lands — intentional.
2026-09-26 17:30:02 +00:00

203 lines
8.8 KiB
Python

"""
Sprint 4.2 QA Gate: Decision branching, loops, subflows in execute_flow_dag.
Stubs — will fail until Goose's Sprint 4.2 code lands.
"""
import pytest
# ---------------------------------------------------------------------------
# 4.2.1 DecisionNode deterministic first-match ordering
# ---------------------------------------------------------------------------
class TestDecisionNode:
def test_first_matching_branch_wins(self, db):
"""When two outcome branches both match, the first one in order wins."""
from workflows.engine import execute_flow_dag
dag = {
"nodes": [
{"id": "start", "type": "trigger", "data": {}},
{
"id": "decision1",
"type": "decision",
"data": {
"outcomes": [
{
"id": "high",
"label": "High Value",
"conditions": [{"field": "amount", "operator": "gte", "value": 1000}],
"logic": "AND",
},
{
"id": "medium",
"label": "Medium Value",
"conditions": [{"field": "amount", "operator": "gte", "value": 500}],
"logic": "AND",
},
]
}
},
{"id": "action_high", "type": "update_record", "data": {"stage": "High"}},
{"id": "action_medium", "type": "update_record", "data": {"stage": "Medium"}},
],
"edges": [
{"source": "start", "target": "decision1"},
{"source": "decision1", "target": "action_high", "sourceHandle": "high"},
{"source": "decision1", "target": "action_medium", "sourceHandle": "medium"},
],
}
# amount=2000 matches both; first branch (high) must win
context = {"amount": 2000}
result = execute_flow_dag(dag, context)
assert result.get("stage") == "High", (
"First matching DecisionNode outcome must win. Got: " + str(result)
)
def test_default_else_branch_taken_when_no_conditions_match(self, db):
"""The Default/Else outcome must execute when no other branch matches."""
from workflows.engine import execute_flow_dag
dag = {
"nodes": [
{"id": "start", "type": "trigger", "data": {}},
{
"id": "dec",
"type": "decision",
"data": {
"outcomes": [
{
"id": "high",
"label": "High",
"conditions": [{"field": "amount", "operator": "gte", "value": 10000}],
"logic": "AND",
},
{"id": "default", "label": "Default", "conditions": [], "logic": "AND"},
]
}
},
{"id": "action_default", "type": "update_record", "data": {"stage": "Default"}},
],
"edges": [
{"source": "start", "target": "dec"},
{"source": "dec", "target": "action_default", "sourceHandle": "default"},
],
}
context = {"amount": 50}
result = execute_flow_dag(dag, context)
assert result.get("stage") == "Default"
# ---------------------------------------------------------------------------
# 4.2.2 SubflowNode recursion depth guard
# ---------------------------------------------------------------------------
class TestSubflowRecursionDepth:
def test_subflow_depth_limit_raises_validation_error(self, db):
"""SubflowNode must raise ValidationError when recursion depth exceeds limit (10)."""
from django.core.exceptions import ValidationError
from workflows.engine import execute_flow_dag
# Build a flow that calls itself (self-referential subflow)
from workflows.models import FlowDefinition
self_ref_dag = {
"nodes": [
{"id": "start", "type": "trigger", "data": {}},
{"id": "sub", "type": "subflow", "data": {"flow_id": None}}, # patched below
],
"edges": [{"source": "start", "target": "sub"}],
}
flow = FlowDefinition.objects.create(
name="RecursiveFlow",
trigger_type="manual",
graph=self_ref_dag,
)
# Patch the subflow node to reference itself
self_ref_dag["nodes"][1]["data"]["flow_id"] = flow.id
flow.graph = self_ref_dag
flow.save()
with pytest.raises((ValidationError, RecursionError, Exception)) as exc_info:
execute_flow_dag(self_ref_dag, {}, depth=0)
assert "depth" in str(exc_info.value).lower() or "recursion" in str(exc_info.value).lower(), (
"SubflowNode must raise a clear depth/recursion limit error, not silently hang."
)
def test_subflow_within_depth_limit_executes(self, db):
"""A subflow at depth < 10 must execute normally."""
from workflows.engine import execute_flow_dag
from workflows.models import FlowDefinition
child_dag = {
"nodes": [
{"id": "start", "type": "trigger", "data": {}},
{"id": "assign", "type": "assignment", "data": {"variable": "child_ran", "value": True}},
],
"edges": [{"source": "start", "target": "assign"}],
}
child = FlowDefinition.objects.create(
name="ChildFlow", trigger_type="manual", graph=child_dag
)
parent_dag = {
"nodes": [
{"id": "start", "type": "trigger", "data": {}},
{"id": "sub", "type": "subflow", "data": {"flow_id": child.id}},
],
"edges": [{"source": "start", "target": "sub"}],
}
result = execute_flow_dag(parent_dag, {}, depth=0)
assert result.get("child_ran") is True
# ---------------------------------------------------------------------------
# 4.2.3 LoopNode cycle detection still enforced
# ---------------------------------------------------------------------------
class TestLoopNodeCycleDetection:
def test_loop_back_edge_rejected_at_save(self, db):
"""A graph where a LoopNode routes back to an ancestor must fail DAG validation."""
from django.core.exceptions import ValidationError
from workflows.models import FlowDefinition
cyclic_dag = {
"nodes": [
{"id": "start", "type": "trigger", "data": {}},
{"id": "loop", "type": "loop", "data": {"collection": "contacts"}},
{"id": "action", "type": "update_record", "data": {}},
],
"edges": [
{"source": "start", "target": "loop"},
{"source": "loop", "target": "action", "sourceHandle": "for_each"},
# back-edge creating a cycle:
{"source": "action", "target": "loop"},
],
}
with pytest.raises(ValidationError):
flow = FlowDefinition(name="CyclicLoop", trigger_type="manual", graph=cyclic_dag)
flow.full_clean()
# ---------------------------------------------------------------------------
# 4.2.4 AssignmentNode execution
# ---------------------------------------------------------------------------
class TestAssignmentNode:
def test_assignment_sets_context_variable(self, db):
"""AssignmentNode must update the execution context variable."""
from workflows.engine import execute_flow_dag
dag = {
"nodes": [
{"id": "start", "type": "trigger", "data": {}},
{"id": "assign", "type": "assignment", "data": {"variable": "score", "operator": "equals", "value": 42}},
],
"edges": [{"source": "start", "target": "assign"}],
}
result = execute_flow_dag(dag, {"score": 0})
assert result["score"] == 42
def test_assignment_add_operator(self, db):
"""AssignmentNode with 'add' operator must increment the variable."""
from workflows.engine import execute_flow_dag
dag = {
"nodes": [
{"id": "start", "type": "trigger", "data": {}},
{"id": "assign", "type": "assignment", "data": {"variable": "score", "operator": "add", "value": 10}},
],
"edges": [{"source": "start", "target": "assign"}],
}
result = execute_flow_dag(dag, {"score": 5})
assert result["score"] == 15