add field name validation to EmbeddedModelField lookups

Author: WaVEV

django_mongodb_backend/fields/embedded_model.py

@@ -1,4 +1,7 @@
+import difflib
+
 from django.core import checks
+from django.core.exceptions import FieldDoesNotExist
 from django.db import models
 from django.db.models.fields.related import lazy_related_operation
 from django.db.models.lookups import Transform
@@ -123,7 +126,8 @@ def get_transform(self, name):
  transform = super().get_transform(name)
  if transform:
  return transform
- return KeyTransformFactory(name)
+ field = self.embedded_model._meta.get_field(name)
+ return KeyTransformFactory(name, field)
 
  def validate(self, value, model_instance):
  super().validate(value, model_instance)
@@ -145,9 +149,36 @@ def formfield(self, **kwargs):
 
 
 class KeyTransform(Transform):
- def __init__(self, key_name, *args, **kwargs):
+ def __init__(self, key_name, ref_field, *args, **kwargs):
  super().__init__(*args, **kwargs)
  self.key_name = str(key_name)
+ self.ref_field = ref_field
+
+ def get_transform(self, name):
+ """
+ Validate that `name` is either a field of an embedded model or a
+ lookup on an embedded model's field.
+ """
+ result = None
+ if isinstance(self.ref_field, EmbeddedModelField):
+ opts = self.ref_field.embedded_model._meta
+ new_field = opts.get_field(name)
+ result = KeyTransformFactory(name, new_field)
+ else:
+ if self.ref_field.get_transform(name) is None:
+ suggested_lookups = difflib.get_close_matches(name, self.ref_field.get_lookups())
+ if suggested_lookups:
+ suggested_lookups = " or ".join(suggested_lookups)
+ suggestion = f", perhaps you meant {suggested_lookups}?"
+ else:
+ suggestion = "."
+ raise FieldDoesNotExist(
+ f"Unsupported lookup '{name}' for "
+ f"{self.ref_field.__class__.__name__} '{self.ref_field.name}'"
+ f"{suggestion}"
+ )
+ result = KeyTransformFactory(name, self.ref_field)
+ return result
 
  def preprocess_lhs(self, compiler, connection):
  key_transforms = [self.key_name]
@@ -165,8 +196,9 @@ def as_mql(self, compiler, connection):
 
 
 class KeyTransformFactory:
- def __init__(self, key_name):
+ def __init__(self, key_name, ref_field):
  self.key_name = key_name
+ self.ref_field = ref_field
 
  def __call__(self, *args, **kwargs):
- return KeyTransform(self.key_name, *args, **kwargs)
+ return KeyTransform(self.key_name, self.ref_field, *args, **kwargs)

tests/model_fields_/test_embedded_model.py

@@ -1,6 +1,6 @@
 import operator
 
-from django.core.exceptions import ValidationError
+from django.core.exceptions import FieldDoesNotExist, ValidationError
 from django.db import models
 from django.db.models import ExpressionWrapper, F, Max, Sum
 from django.test import SimpleTestCase, TestCase
@@ -147,6 +147,41 @@ def test_nested(self):
  self.assertCountEqual(Book.objects.filter(author__address__city="NYC"), [obj])
 
 
+class InvalidLookupTests(SimpleTestCase):
+ def test_invalid_field(self):
+ msg = "Author has no field named 'first_name'"
+ with self.assertRaisesMessage(FieldDoesNotExist, msg):
+ Book.objects.filter(author__first_name="Bob")
+
+ def test_invalid_field_nested(self):
+ msg = "Address has no field named 'floor'"
+ with self.assertRaisesMessage(FieldDoesNotExist, msg):
+ Book.objects.filter(author__address__floor="NYC")
+
+ def test_invalid_lookup(self):
+ msg = "Unsupported lookup 'foo' for CharField 'city'."
+ with self.assertRaisesMessage(FieldDoesNotExist, msg):
+ Book.objects.filter(author__address__city__foo="NYC")
+
+ def test_invalid_lookup_with_suggestions(self):
+ msg = (
+ "Unsupported lookup '{lookup}' for CharField 'name', "
+ "perhaps you meant {suggested_lookups}?"
+ )
+ with self.assertRaisesMessage(
+ FieldDoesNotExist, msg.format(lookup="exactly", suggested_lookups="exact or iexact")
+ ):
+ Book.objects.filter(author__name__exactly="NYC")
+ with self.assertRaisesMessage(
+ FieldDoesNotExist, msg.format(lookup="gti", suggested_lookups="gt or gte")
+ ):
+ Book.objects.filter(author__name__gti="NYC")
+ with self.assertRaisesMessage(
+ FieldDoesNotExist, msg.format(lookup="is_null", suggested_lookups="isnull")
+ ):
+ Book.objects.filter(author__name__is_null="NYC")
+
+
 @isolate_apps("model_fields_")
 class CheckTests(SimpleTestCase):
  def test_no_relational_fields(self):