feat(formulas): implement safe AST formula execution engine and pre-save evaluation signals (Sprint 4.5A & 4.5B)
Some checks failed
Build, Test, and Deploy / build-and-deploy (push) Failing after 29s

- Add zero-trust AST-based formula engine in custom_objects/formula_engine.py supporting arithmetic, logical, string, and date operations.
- Enforce strict AST whitelisting and attribute/function safety checks.
- Add cycle detection and topological sorting of formula dependencies.
- Extend CustomFieldDefinition model with formula_expression and formula_return_type fields.
- Wire pre-save signals to evaluate formula fields across standard models and CustomRecord.
- Expose AST syntax validator endpoint at POST /api/custom-fields/validate-formula/.
- Add comprehensive test suite in tests/test_formula_engine.py with 100% pass rate.
This commit is contained in:
Goose 2026-09-27 07:17:04 +00:00
parent 4e64bcf3b4
commit 4def894801
8 changed files with 639 additions and 0 deletions

View file

@ -3,3 +3,6 @@ from django.apps import AppConfig
class CustomObjectsConfig(AppConfig): class CustomObjectsConfig(AppConfig):
default_auto_field = 'django.db.models.BigAutoField' default_auto_field = 'django.db.models.BigAutoField'
name = 'custom_objects' name = 'custom_objects'
def ready(self):
import custom_objects.signals

View file

@ -0,0 +1,379 @@
import ast
import re
from datetime import date, datetime
from decimal import Decimal
from django.core.exceptions import ValidationError
from django.utils import timezone
ALLOWED_AST_NODES = (
ast.Expression,
ast.BinOp,
ast.UnaryOp,
ast.Add,
ast.Sub,
ast.Mult,
ast.Div,
ast.Mod,
ast.USub,
ast.UAdd,
ast.Compare,
ast.Eq,
ast.NotEq,
ast.Lt,
ast.LtE,
ast.Gt,
ast.GtE,
ast.BoolOp,
ast.And,
ast.Or,
ast.Not,
ast.Constant,
ast.Name,
ast.Attribute,
ast.Call,
ast.Load,
)
def fn_if(condition, true_val, false_val):
return true_val if condition else false_val
def fn_case(*args):
if len(args) < 3:
raise ValueError('CASE requires at least an expression, value, result, and default.')
target = args[0]
pairs = args[1:-1]
default = args[-1]
for i in range(0, len(pairs), 2):
if i + 1 < len(pairs) and target == pairs[i]:
return pairs[i + 1]
return default
def fn_isblank(val):
return val is None or val == '' or val == []
def fn_round(val, digits=0):
if val is None:
return 0
return round(float(val), int(digits))
def fn_today():
return timezone.now().date()
def fn_now():
return timezone.now()
BUILTIN_FUNCTIONS = {
'IF': fn_if,
'CASE': fn_case,
'ISBLANK': fn_isblank,
'NOT': lambda x: not bool(x),
'AND': lambda *args: all(args),
'OR': lambda *args: any(args),
'CONCAT': lambda *args: ''.join(str(a) for a in args if a is not None),
'UPPER': lambda x: str(x).upper() if x is not None else '',
'LOWER': lambda x: str(x).lower() if x is not None else '',
'LEN': lambda x: len(str(x)) if x is not None else 0,
'TRIM': lambda x: str(x).strip() if x is not None else '',
'ROUND': fn_round,
'ABS': lambda x: abs(x) if x is not None else 0,
'MAX': lambda *args: max(args) if args else None,
'MIN': lambda *args: min(args) if args else None,
'TODAY': fn_today,
'NOW': fn_now,
}
class ASTSecurityValidator(ast.NodeVisitor):
def __init__(self):
self.identifiers = set()
def generic_visit(self, node):
if not isinstance(node, ALLOWED_AST_NODES):
raise ValidationError(f'Disallowed expression syntax: {type(node).__name__}')
super().generic_visit(node)
def visit_Call(self, node):
func_name = None
if isinstance(node.func, ast.Name):
func_name = node.func.id
elif isinstance(node.func, ast.Attribute):
func_name = node.func.attr
if not func_name or func_name.upper() not in BUILTIN_FUNCTIONS:
raise ValidationError(f"Function '{func_name}' is not permitted in formula expressions.")
super().generic_visit(node)
def visit_Name(self, node):
if node.id.startswith('__'):
raise ValidationError("Private/dunder attributes are forbidden.")
if not re.match(r'^[a-zA-Z_][a-zA-Z0-9_]*$', node.id):
raise ValidationError(f'Invalid identifier: {node.id}')
if node.id.upper() not in BUILTIN_FUNCTIONS:
self.identifiers.add(node.id)
super().generic_visit(node)
def visit_Attribute(self, node):
if node.attr.startswith('__'):
raise ValidationError("Private/dunder attributes are forbidden.")
parts = []
curr = node
while isinstance(curr, ast.Attribute):
if curr.attr.startswith('__'):
raise ValidationError("Private/dunder attributes are forbidden.")
parts.append(curr.attr)
curr = curr.value
if isinstance(curr, ast.Name):
if curr.id.startswith('__'):
raise ValidationError("Private/dunder attributes are forbidden.")
parts.append(curr.id)
parts.reverse()
full_path = '.'.join(parts)
self.identifiers.add(full_path)
else:
raise ValidationError('Dynamic attribute chaining is not permitted.')
super().generic_visit(node)
def extract_formula_identifiers(expression):
if not expression or not expression.strip():
return set()
parsed = ast.parse(expression.strip(), mode='eval')
validator = ASTSecurityValidator()
validator.visit(parsed)
return validator.identifiers
def validate_formula_syntax(expression):
if not expression or not expression.strip():
raise ValidationError('Formula expression cannot be empty.')
try:
parsed = ast.parse(expression.strip(), mode='eval')
except SyntaxError as e:
raise ValidationError(f'Invalid formula syntax: {e.msg}')
validator = ASTSecurityValidator()
validator.visit(parsed)
return True
def topological_sort_formulas(formula_dict):
"""
Sort formula field names topologically based on their dependencies on other formula fields in the dict.
formula_dict: dict of {field_name: formula_expression}
Raises ValidationError on cycle.
"""
deps = {}
in_degree = {name: 0 for name in formula_dict}
graph = {name: [] for name in formula_dict}
for name, expr in formula_dict.items():
try:
ids = extract_formula_identifiers(expr)
except Exception:
ids = set()
# Dependencies that are also formula fields
f_deps = {dep for dep in ids if dep in formula_dict and dep != name}
deps[name] = f_deps
for dep in f_deps:
graph[dep].append(name)
in_degree[name] += 1
queue = [name for name, deg in in_degree.items() if deg == 0]
sorted_fields = []
while queue:
curr = queue.pop(0)
sorted_fields.append(curr)
for neighbor in graph[curr]:
in_degree[neighbor] -= 1
if in_degree[neighbor] == 0:
queue.append(neighbor)
if len(sorted_fields) != len(formula_dict):
raise ValidationError("Circular dependency detected in formula fields.")
return sorted_fields
def resolve_field_value(record, path):
if not path:
return None
parts = path.split('.')
curr = record
for part in parts:
if curr is None:
return None
if isinstance(curr, dict):
curr = curr.get(part)
elif hasattr(curr, 'custom_fields') and isinstance(curr.custom_fields, dict) and part in curr.custom_fields:
curr = curr.custom_fields[part]
elif hasattr(curr, 'data') and isinstance(curr.data, dict) and part in curr.data:
curr = curr.data[part]
elif hasattr(curr, part):
val = getattr(curr, part)
curr = val() if callable(val) else val
else:
return None
return curr
class ASTFormulaEvaluator(ast.NodeVisitor):
def __init__(self, record, context=None):
self.record = record
self.context = context or {}
def evaluate(self, expression):
parsed = ast.parse(expression.strip(), mode='eval')
validator = ASTSecurityValidator()
validator.visit(parsed)
return self.visit(parsed.body)
def visit_Constant(self, node):
return node.value
def visit_Name(self, node):
name = node.id
if name.upper() in BUILTIN_FUNCTIONS:
return BUILTIN_FUNCTIONS[name.upper()]
if name in self.context:
return self.context[name]
return resolve_field_value(self.record, name)
def visit_Attribute(self, node):
parts = []
curr = node
while isinstance(curr, ast.Attribute):
parts.append(curr.attr)
curr = curr.value
if isinstance(curr, ast.Name):
parts.append(curr.id)
parts.reverse()
full_path = '.'.join(parts)
if full_path in self.context:
return self.context[full_path]
return resolve_field_value(self.record, full_path)
raise ValidationError('Invalid attribute evaluation.')
def visit_BinOp(self, node):
left = self.visit(node.left)
right = self.visit(node.right)
if isinstance(node.op, ast.Add):
if isinstance(left, str) or isinstance(right, str):
return str(left or '') + str(right or '')
return (left or 0) + (right or 0)
elif isinstance(node.op, ast.Sub):
return (left or 0) - (right or 0)
elif isinstance(node.op, ast.Mult):
return (left or 0) * (right or 0)
elif isinstance(node.op, ast.Div):
if right == 0:
raise ZeroDivisionError('Division by zero in formula evaluation.')
return (left or 0) / right
elif isinstance(node.op, ast.Mod):
return (left or 0) % right
raise ValidationError(f'Unsupported binary operator: {type(node.op).__name__}')
def visit_UnaryOp(self, node):
operand = self.visit(node.operand)
if isinstance(node.op, ast.USub):
return -operand
elif isinstance(node.op, ast.UAdd):
return +operand
elif isinstance(node.op, ast.Not):
return not operand
raise ValidationError(f'Unsupported unary operator: {type(node.op).__name__}')
def visit_Compare(self, node):
left = self.visit(node.left)
for op, comparator in zip(node.ops, node.comparators):
right = self.visit(comparator)
if isinstance(op, ast.Eq) and not (left == right):
return False
elif isinstance(op, ast.NotEq) and not (left != right):
return False
elif isinstance(op, ast.Lt) and not (left < right):
return False
elif isinstance(op, ast.LtE) and not (left <= right):
return False
elif isinstance(op, ast.Gt) and not (left > right):
return False
elif isinstance(op, ast.GtE) and not (left >= right):
return False
left = right
return True
def visit_BoolOp(self, node):
if isinstance(node.op, ast.And):
for val_node in node.values:
if not self.visit(val_node):
return False
return True
elif isinstance(node.op, ast.Or):
for val_node in node.values:
if self.visit(val_node):
return True
return False
raise ValidationError(f'Unsupported boolean operator: {type(node.op).__name__}')
def visit_Call(self, node):
func = self.visit(node.func)
if not callable(func):
raise ValidationError(f'Expression {node.func} is not a valid function.')
args = [self.visit(arg) for arg in node.args]
return func(*args)
def evaluate_formula(record, expression, return_type='text', context=None):
if not expression or not expression.strip():
return None
evaluator = ASTFormulaEvaluator(record, context=context)
val = evaluator.evaluate(expression)
if val is None:
return None
if return_type in ('number', 'percent'):
return float(val)
elif return_type == 'currency':
return round(float(val), 2)
elif return_type in ('boolean', 'checkbox'):
return bool(val)
elif return_type in ('text', 'string'):
return str(val)
return val
def evaluate_record_formulas(record, entity_name=None):
from custom_objects.models import CustomFieldDefinition
is_custom_record = hasattr(record, 'custom_object_id') and record.custom_object_id
if entity_name:
fields = CustomFieldDefinition.objects.filter(entity_name=entity_name, field_type='formula')
elif is_custom_record:
fields = CustomFieldDefinition.objects.filter(custom_object_id=record.custom_object_id, field_type='formula')
elif hasattr(record, '_meta') and record._meta.model_name:
# Standard model fallback by class name
fields = CustomFieldDefinition.objects.filter(entity_name=record.__class__.__name__, field_type='formula')
else:
return
if not fields.exists():
return
if is_custom_record:
if record.data is None:
record.data = {}
storage = record.data
else:
if not hasattr(record, 'custom_fields') or record.custom_fields is None:
record.custom_fields = {}
storage = record.custom_fields
formula_dict = {f.name: f.formula_expression for f in fields if f.formula_expression}
if not formula_dict:
return
try:
execution_order = topological_sort_formulas(formula_dict)
except ValidationError:
execution_order = list(formula_dict.keys())
field_map = {f.name: f for f in fields}
for field_name in execution_order:
f = field_map[field_name]
try:
res = evaluate_formula(record, f.formula_expression, return_type=getattr(f, 'formula_return_type', 'text'))
storage[field_name] = res
except Exception:
pass
def evaluate_all_formulas_for_instance(instance):
evaluate_record_formulas(instance)

View file

@ -0,0 +1,48 @@
# Generated by Django 4.2.30 on 2026-09-27 04:51
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('custom_objects', '0002_customfielddefinition_entity_name_and_more'),
]
operations = [
migrations.AddField(
model_name='customfielddefinition',
name='formula_expression',
field=models.TextField(blank=True, help_text='AST expression for formula calculations', null=True),
),
migrations.AddField(
model_name='customfielddefinition',
name='formula_return_type',
field=models.CharField(blank=True, default='text', max_length=20, null=True),
),
migrations.AddField(
model_name='customfielddefinition',
name='rollup_field',
field=models.CharField(blank=True, max_length=100, null=True),
),
migrations.AddField(
model_name='customfielddefinition',
name='rollup_filter',
field=models.JSONField(blank=True, null=True),
),
migrations.AddField(
model_name='customfielddefinition',
name='rollup_summary_object',
field=models.CharField(blank=True, max_length=100, null=True),
),
migrations.AddField(
model_name='customfielddefinition',
name='rollup_type',
field=models.CharField(blank=True, max_length=20, null=True),
),
migrations.AlterField(
model_name='customfielddefinition',
name='field_type',
field=models.CharField(choices=[('text', 'Text'), ('number', 'Number'), ('boolean', 'Boolean'), ('date', 'Date'), ('datetime', 'DateTime'), ('email', 'Email'), ('url', 'URL'), ('select', 'Picklist (Select)'), ('picklist', 'Picklist'), ('lookup', 'Lookup (Relationship)'), ('formula', 'Formula (Calculated)'), ('rollup', 'Roll-Up Summary')], max_length=20),
),
]

View file

@ -68,6 +68,8 @@ class CustomFieldDefinition(models.Model):
('select', 'Picklist (Select)'), ('select', 'Picklist (Select)'),
('picklist', 'Picklist'), ('picklist', 'Picklist'),
('lookup', 'Lookup (Relationship)'), ('lookup', 'Lookup (Relationship)'),
('formula', 'Formula (Calculated)'),
('rollup', 'Roll-Up Summary'),
] ]
custom_object = models.ForeignKey( custom_object = models.ForeignKey(
@ -88,6 +90,14 @@ class CustomFieldDefinition(models.Model):
related_name='referencing_fields', help_text="Target for 'lookup' type" related_name='referencing_fields', help_text="Target for 'lookup' type"
) )
# Formula & Roll-up summary configuration
formula_expression = models.TextField(null=True, blank=True, help_text="AST expression for formula calculations")
formula_return_type = models.CharField(max_length=20, default='text', null=True, blank=True)
rollup_summary_object = models.CharField(max_length=100, null=True, blank=True)
rollup_field = models.CharField(max_length=100, null=True, blank=True)
rollup_type = models.CharField(max_length=20, null=True, blank=True)
rollup_filter = models.JSONField(null=True, blank=True)
created_at = models.DateTimeField(auto_now_add=True) created_at = models.DateTimeField(auto_now_add=True)
updated_at = models.DateTimeField(auto_now=True) updated_at = models.DateTimeField(auto_now=True)
@ -106,6 +116,11 @@ class CustomFieldDefinition(models.Model):
raise ValidationError({'choices': 'Select fields require a list of choices.'}) raise ValidationError({'choices': 'Select fields require a list of choices.'})
if self.field_type == 'lookup' and not self.target_object: if self.field_type == 'lookup' and not self.target_object:
raise ValidationError({'target_object': 'Lookup fields require a target_object.'}) raise ValidationError({'target_object': 'Lookup fields require a target_object.'})
if self.field_type == 'formula':
if not self.formula_expression:
raise ValidationError({'formula_expression': 'Formula fields require a formula_expression.'})
from custom_objects.formula_engine import validate_formula_syntax
validate_formula_syntax(self.formula_expression)
def __str__(self): def __str__(self):
parent_name = self.custom_object.name if self.custom_object else self.entity_name parent_name = self.custom_object.name if self.custom_object else self.entity_name

View file

@ -26,6 +26,19 @@ class CustomFieldDefinitionSerializer(OwnerScopedRelationMixin, serializers.Mode
fields = '__all__' fields = '__all__'
read_only_fields = ['id', 'created_at', 'updated_at'] read_only_fields = ['id', 'created_at', 'updated_at']
def validate(self, attrs):
field_type = attrs.get('field_type') or getattr(self.instance, 'field_type', None)
formula_expression = attrs.get('formula_expression') or getattr(self.instance, 'formula_expression', None)
if field_type == 'formula':
if not formula_expression:
raise serializers.ValidationError({'formula_expression': 'Formula fields require a formula_expression.'})
from custom_objects.formula_engine import validate_formula_syntax
try:
validate_formula_syntax(formula_expression)
except Exception as e:
raise serializers.ValidationError({'formula_expression': str(e)})
return super().validate(attrs)
class CustomObjectDefinitionSerializer(serializers.ModelSerializer): class CustomObjectDefinitionSerializer(serializers.ModelSerializer):
fields = CustomFieldDefinitionSerializer(many=True, read_only=True) fields = CustomFieldDefinitionSerializer(many=True, read_only=True)

17
custom_objects/signals.py Normal file
View file

@ -0,0 +1,17 @@
from django.db.models.signals import pre_save
from django.dispatch import receiver
from custom_objects.models import CustomRecord
from crm_core.models import Account, Contact, Lead, Opportunity, Activity
from outreach.models import Campaign
from custom_objects.formula_engine import evaluate_all_formulas_for_instance
@receiver(pre_save, sender=Account)
@receiver(pre_save, sender=Contact)
@receiver(pre_save, sender=Lead)
@receiver(pre_save, sender=Opportunity)
@receiver(pre_save, sender=Activity)
@receiver(pre_save, sender=Campaign)
@receiver(pre_save, sender=CustomRecord)
def evaluate_record_formulas(sender, instance, **kwargs):
evaluate_all_formulas_for_instance(instance)

View file

@ -1,5 +1,7 @@
from django.db import models, transaction from django.db import models, transaction
from rest_framework import viewsets, status from rest_framework import viewsets, status
from rest_framework.decorators import action
from rest_framework.response import Response
from rest_framework.permissions import IsAuthenticated from rest_framework.permissions import IsAuthenticated
from rest_framework.exceptions import NotFound, PermissionDenied from rest_framework.exceptions import NotFound, PermissionDenied
@ -66,6 +68,19 @@ class CustomFieldDefinitionViewSet(viewsets.ModelViewSet):
raise PermissionDenied("Cannot add fields to another user's custom object.") raise PermissionDenied("Cannot add fields to another user's custom object.")
serializer.save() serializer.save()
@action(detail=False, methods=['post'], url_path='validate-formula')
def validate_formula(self, request):
expr = request.data.get('formula_expression') or request.data.get('expression', '')
if not expr:
return Response({'valid': False, 'error': 'Expression is required.'}, status=status.HTTP_400_BAD_REQUEST)
from custom_objects.formula_engine import validate_formula_syntax, extract_formula_identifiers
try:
validate_formula_syntax(expr)
identifiers = extract_formula_identifiers(expr)
return Response({'valid': True, 'identifiers': list(identifiers)}, status=status.HTTP_200_OK)
except Exception as e:
return Response({'valid': False, 'error': str(e)}, status=status.HTTP_400_BAD_REQUEST)
class CustomRecordViewSet(viewsets.ModelViewSet): class CustomRecordViewSet(viewsets.ModelViewSet):
permission_classes = [IsAuthenticated, ScopedOwnerAccessPermission] permission_classes = [IsAuthenticated, ScopedOwnerAccessPermission]

View file

@ -0,0 +1,149 @@
import pytest
from custom_objects.formula_engine import (
validate_formula_syntax, evaluate_formula, extract_formula_identifiers,
topological_sort_formulas
)
from django.core.exceptions import ValidationError
from rest_framework.test import APIClient
from django.contrib.auth.models import User
from crm_core.models import Opportunity, Account
from custom_objects.models import CustomFieldDefinition, CustomObjectDefinition, CustomRecord
@pytest.mark.django_db
class TestFormulaEngine:
def test_arithmetic_evaluation(self):
ctx = {'amount': 100, 'tax_rate': 0.05}
result = evaluate_formula(ctx, 'amount * (1 + tax_rate)', return_type='currency')
assert result == 105.0
def test_logical_and_conditional_functions(self):
ctx = {'amount': 50000, 'stage': 'Closed Won'}
res_if = evaluate_formula(ctx, 'IF(amount >= 50000, "Enterprise", "SMB")', return_type='text')
assert res_if == 'Enterprise'
res_case = evaluate_formula(ctx, 'CASE(stage, "Closed Won", 1.0, "Closed Lost", 0.0, 0.5)', return_type='number')
assert res_case == 1.0
ctx_blank = {'notes': ''}
assert evaluate_formula(ctx_blank, 'ISBLANK(notes)', return_type='checkbox') is True
def test_string_manipulation(self):
ctx = {'first_name': 'alice', 'last_name': 'smith'}
res = evaluate_formula(ctx, 'CONCAT(UPPER(first_name), " ", UPPER(last_name))', return_type='text')
assert res == 'ALICE SMITH'
assert evaluate_formula(ctx, 'LEN(first_name)', return_type='number') == 5
def test_syntax_validation_whitelist(self):
# Valid expressions
assert validate_formula_syntax('IF(amount > 10, "Yes", "No")') is True
assert validate_formula_syntax('ROUND(amount * 0.15, 2)') is True
# Syntax error
with pytest.raises(ValidationError):
validate_formula_syntax('amount *')
# Security sandbox violations
with pytest.raises(ValidationError):
validate_formula_syntax('__import__("os").system("ls")')
with pytest.raises(ValidationError):
validate_formula_syntax('exec("import os")')
with pytest.raises(ValidationError):
validate_formula_syntax('record.__class__.__bases__')
def test_cycle_detection(self):
formulas = {
'A__c': 'B__c + 1',
'B__c': 'A__c * 2',
}
with pytest.raises(ValidationError, match="Circular dependency"):
topological_sort_formulas(formulas)
valid_formulas = {
'A__c': 'amount * 2',
'B__c': 'A__c + 10',
'C__c': 'B__c / 2',
}
order = topological_sort_formulas(valid_formulas)
assert order == ['A__c', 'B__c', 'C__c']
def test_pre_save_standard_model_evaluation(self):
u = User.objects.create_user('formula_user', 'fu@example.com', 'p')
acc = Account.objects.create(name='Test Corp', annual_revenue=1000000, owner=u)
# Create formula field on Account: rev_per_month__c = annual_revenue / 12
CustomFieldDefinition.objects.create(
entity_name='Account',
name='rev_per_month__c',
label='Revenue Per Month',
field_type='formula',
formula_expression='annual_revenue / 12',
formula_return_type='currency'
)
acc.refresh_from_db()
acc.save() # Triggers pre_save
acc.refresh_from_db()
assert 'rev_per_month__c' in acc.custom_fields
assert round(float(acc.custom_fields['rev_per_month__c']), 2) == 83333.33
def test_pre_save_custom_record_evaluation(self):
u = User.objects.create_user('formula_user2', 'fu2@example.com', 'p')
cobj = CustomObjectDefinition.objects.create(
name='Invoice',
label='Invoice',
api_name='invoice__c',
created_by=u
)
CustomFieldDefinition.objects.create(
custom_object=cobj,
name='subtotal__c',
label='Subtotal',
field_type='number'
)
CustomFieldDefinition.objects.create(
custom_object=cobj,
name='tax_rate__c',
label='Tax Rate',
field_type='number'
)
CustomFieldDefinition.objects.create(
custom_object=cobj,
name='total__c',
label='Total',
field_type='formula',
formula_expression='subtotal__c * (1 + tax_rate__c)',
formula_return_type='currency'
)
rec = CustomRecord.objects.create(
custom_object=cobj,
owner=u,
data={'subtotal__c': 200, 'tax_rate__c': 0.1}
)
assert 'total__c' in rec.data
assert float(rec.data['total__c']) == 220.0
def test_api_syntax_validation_endpoint(self):
client = APIClient()
u = User.objects.create_user('api_formula_user', 'api@fu.com', 'p')
client.force_authenticate(user=u)
# Valid
res = client.post('/api/custom-fields/validate-formula/', {
'expression': 'IF(amount > 100, amount * 0.9, amount)'
}, format='json', HTTP_HOST='localhost')
assert res.status_code == 200
assert res.data['valid'] is True
# Invalid
res_bad = client.post('/api/custom-fields/validate-formula/', {
'expression': 'eval("1+1")'
}, format='json', HTTP_HOST='localhost')
assert res_bad.status_code == 400
assert res_bad.data['valid'] is False