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.
This commit is contained in:
Goose 2026-09-26 17:30:02 +00:00
parent 616e7b2057
commit eaaf3f2791
4 changed files with 531 additions and 0 deletions

0
tests/phase4/__init__.py Normal file
View file

View file

@ -0,0 +1,178 @@
"""
Sprint 4.1 QA Gate: Custom __c fields on standard CRM objects.
All tests are contract stubs — they will fail (ImportError or NotImplementedError)
until Goose's Sprint 4.1 code lands. That is intentional.
"""
import pytest
# ---------------------------------------------------------------------------
# 4.1.1 entity_name / custom_object mutual exclusion
# ---------------------------------------------------------------------------
class TestCustomFieldDefinitionEntityConstraint:
"""CustomFieldDefinition must have EITHER custom_object OR entity_name, not both, not neither."""
def test_entity_name_without_custom_object_is_valid(self, db):
"""A field attached to a standard object (entity_name='Account') is valid."""
from custom_objects.models import CustomFieldDefinition
field = CustomFieldDefinition(
name="annual_revenue_tier__c",
label="Annual Revenue Tier",
field_type="text",
entity_name="Account",
)
# Should not raise
field.full_clean()
def test_custom_object_without_entity_name_is_valid(self, db):
"""A field attached to a CustomObjectDefinition is valid."""
from custom_objects.models import CustomObjectDefinition, CustomFieldDefinition
obj = CustomObjectDefinition(name="Project__c", label="Project", plural_label="Projects")
obj.save()
field = CustomFieldDefinition(
name="budget__c",
label="Budget",
field_type="number",
custom_object=obj,
)
field.full_clean()
def test_both_entity_name_and_custom_object_raises(self, db):
"""Setting both entity_name and custom_object must be rejected."""
from django.core.exceptions import ValidationError
from custom_objects.models import CustomObjectDefinition, CustomFieldDefinition
obj = CustomObjectDefinition(name="Project__c", label="Project", plural_label="Projects")
obj.save()
field = CustomFieldDefinition(
name="bad_field__c",
label="Bad Field",
field_type="text",
entity_name="Account",
custom_object=obj,
)
with pytest.raises(ValidationError):
field.full_clean()
def test_neither_entity_name_nor_custom_object_raises(self, db):
"""Setting neither entity_name nor custom_object must be rejected."""
from django.core.exceptions import ValidationError
from custom_objects.models import CustomFieldDefinition
field = CustomFieldDefinition(
name="orphan__c",
label="Orphan",
field_type="text",
)
with pytest.raises(ValidationError):
field.full_clean()
# ---------------------------------------------------------------------------
# 4.1.2 GIN index present in migration (not just model Meta)
# ---------------------------------------------------------------------------
class TestCustomFieldsGINIndex:
"""Verify the GIN index on custom_fields is declared in the migration SQL."""
def test_gin_index_in_migration_sql(self):
"""The migration adding custom_fields must include a GIN index creation."""
import os, re
migration_dir = os.path.join(
os.path.dirname(__file__), '..', '..', 'crm_core', 'migrations'
)
migration_files = sorted(f for f in os.listdir(migration_dir) if f.endswith('.py'))
gin_found = False
for fname in migration_files:
path = os.path.join(migration_dir, fname)
content = open(path).read()
if 'custom_fields' in content and re.search(r'gin|GIN|GinIndex', content):
gin_found = True
break
assert gin_found, (
"No migration found that adds a GIN index on custom_fields. "
"The index must be in the migration, not just model Meta."
)
# ---------------------------------------------------------------------------
# 4.1.3 additionalProperties: False on standard object endpoints
# ---------------------------------------------------------------------------
class TestStandardObjectCustomFieldValidation:
"""Standard object serializers must reject unknown custom_fields keys."""
def test_unknown_custom_field_key_rejected_on_account(self, db):
"""POST to Account with an unknown custom_fields key must return 400."""
from django.contrib.auth.models import User
from rest_framework.test import APIClient
user = User.objects.create_user('qa_user41', password='pass')
client = APIClient()
client.force_authenticate(user=user)
payload = {
'name': 'Acme Corp',
'custom_fields': {'nonexistent_field__c': 'some_value'},
}
response = client.post('/api/accounts/', payload, format='json')
assert response.status_code == 400, (
f"Expected 400 for unknown custom_fields key, got {response.status_code}. "
"additionalProperties: False must be enforced on standard object endpoints."
)
def test_registered_custom_field_accepted_on_account(self, db):
"""POST with a registered __c field must be accepted (201)."""
from django.contrib.auth.models import User
from rest_framework.test import APIClient
from custom_objects.models import CustomFieldDefinition
# Register a custom field for Account
CustomFieldDefinition.objects.create(
name="region__c",
label="Region",
field_type="text",
entity_name="Account",
is_required=False,
)
user = User.objects.create_user('qa_user41b', password='pass')
client = APIClient()
client.force_authenticate(user=user)
payload = {
'name': 'Acme Corp',
'custom_fields': {'region__c': 'EMEA'},
}
response = client.post('/api/accounts/', payload, format='json')
assert response.status_code == 201, (
f"Expected 201 for valid registered custom field, got {response.status_code}."
)
def test_custom_fields_preserved_on_lead_conversion(self, db):
"""Custom __c fields on Lead must transfer to the resulting Contact during conversion."""
from django.contrib.auth.models import User
from rest_framework.test import APIClient
from custom_objects.models import CustomFieldDefinition
CustomFieldDefinition.objects.create(
name="referral_source__c",
label="Referral Source",
field_type="text",
entity_name="Lead",
is_required=False,
)
user = User.objects.create_user('qa_user41c', password='pass')
client = APIClient()
client.force_authenticate(user=user)
# Create lead with custom field
lead_resp = client.post('/api/leads/', {
'first_name': 'Jane',
'last_name': 'Doe',
'email': 'jane@example.com',
'company': 'Acme',
'custom_fields': {'referral_source__c': 'Partner'},
}, format='json')
assert lead_resp.status_code == 201
lead_id = lead_resp.data['id']
# Convert
conv_resp = client.post(f'/api/leads/{lead_id}/convert/', {
'create_opportunity': False,
}, format='json')
assert conv_resp.status_code == 200
# Check Contact has the custom field value
contact_id = conv_resp.data.get('contact_id')
contact_resp = client.get(f'/api/contacts/{contact_id}/')
assert contact_resp.data.get('custom_fields', {}).get('referral_source__c') == 'Partner', (
"custom_fields must transfer from Lead to Contact during conversion."
)

View file

@ -0,0 +1,203 @@
"""
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

View file

@ -0,0 +1,150 @@
"""
Sprint 4.3 QA Gate: post_save signals, re-entrancy guard, Celery Beat idempotency.
Stubs — will fail until Goose's Sprint 4.3 code lands.
"""
import pytest
# ---------------------------------------------------------------------------
# 4.3.1 post_save signal dispatches flow for record_created trigger
# ---------------------------------------------------------------------------
class TestRecordTriggeredFlows:
def test_record_created_trigger_fires_on_account_save(self, db):
"""Creating an Account must dispatch any active record_created flow for Account."""
from unittest.mock import patch
from workflows.models import FlowDefinition
from workflows import dispatcher # to be created in Sprint 4.3
flow = FlowDefinition.objects.create(
name="OnAccountCreate",
trigger_type="record_created",
trigger_object="Account",
is_active=True,
graph={
"nodes": [{"id": "start", "type": "trigger", "data": {}}],
"edges": [],
},
)
with patch.object(dispatcher, 'dispatch_flow', wraps=dispatcher.dispatch_flow) as mock_dispatch:
from crm_core.models import Account
Account.objects.create(name="TriggerTest Corp")
mock_dispatch.assert_called_once()
call_kwargs = mock_dispatch.call_args
assert call_kwargs[0][0].id == flow.id or call_kwargs[1].get('flow_id') == flow.id
def test_record_updated_trigger_includes_prior_record(self, db):
"""record_updated flow context must include $Record and $Record__Prior."""
from workflows import dispatcher
from workflows.models import FlowDefinition
from crm_core.models import Account
from unittest.mock import patch
FlowDefinition.objects.create(
name="OnAccountUpdate",
trigger_type="record_updated",
trigger_object="Account",
is_active=True,
graph={
"nodes": [{"id": "start", "type": "trigger", "data": {}}],
"edges": [],
},
)
acct = Account.objects.create(name="Before")
dispatched_contexts = []
original = dispatcher.dispatch_flow
def capture(*args, **kwargs):
dispatched_contexts.append(kwargs.get('context', args[1] if len(args) > 1 else {}))
return original(*args, **kwargs)
with patch.object(dispatcher, 'dispatch_flow', side_effect=capture):
acct.name = "After"
acct.save()
assert len(dispatched_contexts) == 1
ctx = dispatched_contexts[0]
assert '$Record' in ctx, "Context must include $Record"
assert '$Record__Prior' in ctx, "Context must include $Record__Prior"
assert ctx['$Record']['name'] == 'After'
assert ctx['$Record__Prior']['name'] == 'Before'
# ---------------------------------------------------------------------------
# 4.3.2 Re-entrancy guard prevents signal recursion
# ---------------------------------------------------------------------------
class TestSignalReentrancyGuard:
def test_flow_updating_record_does_not_retrigger(self, db):
"""A flow that updates the triggering record must not cause infinite signal recursion."""
from workflows.models import FlowDefinition
from crm_core.models import Account
# Flow that updates a field on the triggering Account
update_self_dag = {
"nodes": [
{"id": "start", "type": "trigger", "data": {}},
{"id": "upd", "type": "update_record", "data": {"field": "name", "value": "Updated by Flow"}},
],
"edges": [{"source": "start", "target": "upd"}],
}
FlowDefinition.objects.create(
name="SelfUpdateFlow",
trigger_type="record_updated",
trigger_object="Account",
is_active=True,
graph=update_self_dag,
)
acct = Account.objects.create(name="Original")
# This must complete without RecursionError or hitting Django's recursion limit
import threading
errors = []
def do_update():
try:
acct.name = "Trigger"
acct.save()
except Exception as e:
errors.append(e)
t = threading.Thread(target=do_update)
t.start()
t.join(timeout=5)
assert not t.is_alive(), "Signal handler appears to be in an infinite loop (timeout exceeded)"
assert not errors, f"Signal handler raised: {errors[0]}"
# ---------------------------------------------------------------------------
# 4.3.3 Scheduled flow Celery Beat idempotency
# ---------------------------------------------------------------------------
class TestScheduledFlowIdempotency:
def test_duplicate_scheduled_dispatch_is_noop(self, db):
"""A second Celery dispatch for the same FlowDefinition + time window must be a no-op."""
from workflows.models import FlowDefinition, FlowExecutionLog
from workflows import tasks as flow_tasks # Celery task module
flow = FlowDefinition.objects.create(
name="DailySync",
trigger_type="scheduled",
is_active=True,
graph={
"nodes": [{"id": "start", "type": "trigger", "data": {}}],
"edges": [],
},
)
window = "2026-09-26T00:00:00Z"
# First dispatch — should run
flow_tasks.run_scheduled_flow(flow.id, window)
count_after_first = FlowExecutionLog.objects.filter(flow_definition=flow).count()
assert count_after_first == 1
# Second dispatch with same window — must be a no-op
flow_tasks.run_scheduled_flow(flow.id, window)
count_after_second = FlowExecutionLog.objects.filter(flow_definition=flow).count()
assert count_after_second == 1, (
"Duplicate scheduled dispatch must not create a second FlowExecutionLog. "
f"Got {count_after_second} logs."
)