From eaaf3f2791592603ca9452fd06d1d2c73be99233 Mon Sep 17 00:00:00 2001 From: Goose Date: Sat, 26 Sep 2026 17:30:02 +0000 Subject: [PATCH] test(phase4): add Sprint 4.1/4.2/4.3 QA gate stubs MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 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. --- tests/phase4/__init__.py | 0 tests/phase4/test_sprint41_custom_fields.py | 178 +++++++++++++++++ tests/phase4/test_sprint42_flow_engine.py | 203 ++++++++++++++++++++ tests/phase4/test_sprint43_triggers.py | 150 +++++++++++++++ 4 files changed, 531 insertions(+) create mode 100644 tests/phase4/__init__.py create mode 100644 tests/phase4/test_sprint41_custom_fields.py create mode 100644 tests/phase4/test_sprint42_flow_engine.py create mode 100644 tests/phase4/test_sprint43_triggers.py diff --git a/tests/phase4/__init__.py b/tests/phase4/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/tests/phase4/test_sprint41_custom_fields.py b/tests/phase4/test_sprint41_custom_fields.py new file mode 100644 index 0000000..40b196f --- /dev/null +++ b/tests/phase4/test_sprint41_custom_fields.py @@ -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." + ) diff --git a/tests/phase4/test_sprint42_flow_engine.py b/tests/phase4/test_sprint42_flow_engine.py new file mode 100644 index 0000000..d2cae08 --- /dev/null +++ b/tests/phase4/test_sprint42_flow_engine.py @@ -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 diff --git a/tests/phase4/test_sprint43_triggers.py b/tests/phase4/test_sprint43_triggers.py new file mode 100644 index 0000000..4cb57e0 --- /dev/null +++ b/tests/phase4/test_sprint43_triggers.py @@ -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." + )