edits

Author: timgraham

django_mongodb/fields/auto.py

@@ -19,6 +19,22 @@ def deconstruct(self):
             path = path.replace("django_mongodb.fields.auto", "django_mongodb.fields")
         return name, path, args, kwargs
 
+    def get_prep_value(self, value):
+        if value is None:
+            return None
+        # Accept int for compatibility with Django's test suite which has many
+        # instances of manually assigned integer IDs, as well as for things
+        # like settings.SITE_ID which has a system check requiring an integer.
+        if isinstance(value, (ObjectId | int)):
+            return value
+        try:
+            return ObjectId(value)
+        except errors.InvalidId as e:
+            # A manually assigned integer ID?
+            if isinstance(value, str) and value.isdigit():
+                return int(value)
+            raise ValueError(f"Field '{self.name}' expected an ObjectId but got {value!r}.") from e
+
     def get_internal_type(self):
         return "ObjectIdAutoField"
 
@@ -27,10 +43,10 @@ def to_python(self, value):
             return value
         try:
             return ObjectId(value)
-        except (errors.InvalidId, TypeError):
+        except errors.InvalidId:
             try:
                 return int(value)
-            except (ValueError, TypeError):
+            except ValueError:
                 raise exceptions.ValidationError(
                     self.error_messages["invalid"],
                     code="invalid",

django_mongodb/fields/objectid.py

@@ -13,36 +13,19 @@ class ObjectIdMixin:
     def db_type(self, connection):
         return "objectId"
 
+    def rel_db_type(self, connection):
+        return "objectId"
+
     def get_prep_value(self, value):
         if value is None:
             return None
-        # Accept int for compatibility with Django's test suite which has many
-        # instances of manually assigned integer IDs, as well as for things
-        # like settings.SITE_ID which has a system check requiring an integer.
-        if isinstance(value, (ObjectId | int)):
+        if isinstance(value, ObjectId):
             return value
         try:
             return ObjectId(value)
         except (errors.InvalidId, TypeError) as e:
-            # A manually assigned integer ID?
-            if isinstance(value, str) and value.isdigit():
-                return int(value)
             raise ValueError(f"Field '{self.name}' expected an ObjectId but got {value!r}.") from e
 
-    def rel_db_type(self, connection):
-        return "objectId"
-
-
-class ObjectIdField(ObjectIdMixin, Field):
-    def get_internal_type(self):
-        return "ObjectIdField"
-
-    def deconstruct(self):
-        name, path, args, kwargs = super().deconstruct()
-        if path.startswith("django_mongodb.fields.objectid"):
-            path = path.replace("django_mongodb.fields.objectid", "django_mongodb.fields")
-        return name, path, args, kwargs
-
     def to_python(self, value):
         if value is None:
             return value
@@ -54,3 +37,14 @@ def to_python(self, value):
                 code="invalid",
                 params={"value": value},
             ) from None
+
+
+class ObjectIdField(ObjectIdMixin, Field):
+    def deconstruct(self):
+        name, path, args, kwargs = super().deconstruct()
+        if path.startswith("django_mongodb.fields.objectid"):
+            path = path.replace("django_mongodb.fields.objectid", "django_mongodb.fields")
+        return name, path, args, kwargs
+
+    def get_internal_type(self):
+        return "ObjectIdField"

docs/source/fields.rst

@@ -0,0 +1,13 @@
+Model ``Field`` reference
+=========================
+
+.. module:: django_mongodb.fields
+
+Some MongoDB-specific fields are available in ``django_mongodb.fields``.
+
+``ObjectIdField``
+-----------------
+
+.. class:: ObjectIdField
+
+Stores an :class:`~bson.objectid.ObjectId`.

docs/source/index.rst

@@ -5,6 +5,7 @@ django-mongodb 5.0.x documentation
    :maxdepth: 1
    :caption: Contents:
 
+   fields
    querysets
 
 Indices and tables

tests/model_fields_/test_objectidfield.py

@@ -18,28 +18,40 @@ def test_get_internal_type(self):
         self.assertEqual(f.get_internal_type(), "ObjectIdField")
 
     def test_to_python_string(self):
-        base_string = "1" * 24
-        expected = ObjectId(base_string)
-        self.assertEqual(ObjectIdField().to_python(base_string), expected)
+        value = "1" * 24
+        self.assertEqual(ObjectIdField().to_python(value), ObjectId(value))
 
     def test_to_python_objectid(self):
-        base_string = "1" * 24
-        expected = ObjectId(base_string)
-        self.assertEqual(ObjectIdField().to_python(expected), expected)
+        value = ObjectId("1" * 24)
+        self.assertEqual(ObjectIdField().to_python(value), value)
 
-    def test_to_python_null_value(self):
+    def test_to_python_null(self):
         self.assertIsNone(ObjectIdField().to_python(None))
 
     def test_to_python_invalid_value(self):
-        for invalid_value in ["None", {}, []]:
+        f = ObjectIdField()
+        for invalid_value in ["None", {}, [], 123]:
             with self.subTest(invalid_value=invalid_value):
                 msg = f"['“{invalid_value}” value must be an Object Id.']"
                 with self.assertRaisesMessage(exceptions.ValidationError, msg):
-                    ObjectIdField().to_python(invalid_value)
+                    f.to_python(invalid_value)
+
+    def test_get_prep_value_string(self):
+        value = "1" * 24
+        self.assertEqual(ObjectIdField().get_prep_value(value), ObjectId(value))
+
+    def test_get_prep_value_objectid(self):
+        value = ObjectId("1" * 24)
+        self.assertEqual(ObjectIdField().get_prep_value(value), value)
 
-    def test_get_prep_value_invalud_values(self):
-        for invalid_value in ["None", {}, []]:
+    def test_get_prep_valuen_null(self):
+        self.assertIsNone(ObjectIdField().to_python(None))
+
+    def test_get_prep_value_invalid_values(self):
+        f = ObjectIdField()
+        f.name = "test"
+        for invalid_value in ["None", {}, [], 123]:
             with self.subTest(invalid_value=invalid_value):
-                msg = f"Field '{None}' expected an ObjectId but got {invalid_value!r}."
+                msg = f"Field 'test' expected an ObjectId but got {invalid_value!r}."
                 with self.assertRaisesMessage(ValueError, msg):
-                    ObjectIdField().get_prep_value(invalid_value)
+                    f.get_prep_value(invalid_value)

tests/queries_/test_objectid.py

@@ -4,7 +4,7 @@
 from .models import Tag
 
 
-class QueriesFilterByObjectId(TestCase):
+class ObjectIdTests(TestCase):
     @classmethod
     def setUpTestData(cls):
         cls.group_id_str_1 = "1" * 24
@@ -19,72 +19,72 @@ def setUpTestData(cls):
         cls.t5 = Tag.objects.create(name="t5", parent=cls.t3)
 
     def test_filter_group_id_is_null_false(self):
-        """Filter objects where group_id is not null"""
+        """Filter objects where group_id is not null."""
         qs = Tag.objects.filter(group_id__isnull=False).order_by("name")
         self.assertSequenceEqual(qs, [self.t3, self.t4])
 
     def test_filter_group_id_is_null_true(self):
-        """Filter objects where group_id is null"""
+        """Filter objects where group_id is null."""
         qs = Tag.objects.filter(group_id__isnull=True).order_by("name")
         self.assertSequenceEqual(qs, [self.t1, self.t2, self.t5])
 
     def test_filter_group_id_equal_str(self):
-        """Filter by group_id with a specific string value"""
+        """Filter by group_id with a specific string value."""
         qs = Tag.objects.filter(group_id=self.group_id_str_1).order_by("name")
         self.assertSequenceEqual(qs, [self.t3])
 
     def test_filter_group_id_equal_obj(self):
-        """Filter by group_id with a specific ObjectId value"""
+        """Filter by group_id with a specific ObjectId value."""
         qs = Tag.objects.filter(group_id=self.group_id_obj_1).order_by("name")
         self.assertSequenceEqual(qs, [self.t3])
 
     def test_filter_group_id_in_str_values(self):
-        """Filter by group_id with string values in a list"""
+        """Filter by group_id with string values in a list."""
         qs = Tag.objects.filter(group_id__in=[self.group_id_str_1, self.group_id_str_2]).order_by(
             "name"
         )
         self.assertSequenceEqual(qs, [self.t3, self.t4])
 
     def test_filter_group_id_in_obj_values(self):
-        """Filter by group_id with ObjectId values in a list"""
+        """Filter by group_id with ObjectId values in a list."""
         qs = Tag.objects.filter(group_id__in=[self.group_id_obj_1, self.group_id_obj_2]).order_by(
             "name"
         )
         self.assertSequenceEqual(qs, [self.t3, self.t4])
 
     def test_filter_group_id_equal_subquery(self):
-        """Filter by group_id using a subquery"""
+        """Filter by group_id using a subquery."""
         subquery = Tag.objects.filter(name="t3").values("group_id")
         qs = Tag.objects.filter(group_id__in=subquery).order_by("name")
         self.assertSequenceEqual(qs, [self.t3])
 
     def test_filter_group_id_in_subquery(self):
-        """Filter by group_id using a subquery with multiple values"""
+        """Filter by group_id using a subquery with multiple values."""
         subquery = Tag.objects.filter(name__in=["t3", "t4"]).values("group_id")
         qs = Tag.objects.filter(group_id__in=subquery).order_by("name")
         self.assertSequenceEqual(qs, [self.t3, self.t4])
 
     def test_filter_parent_by_children_values_str(self):
-        """Query to select parents of children with specific string group_id"""
+        """Query to select parents of children with specific string group_id."""
         child_ids = Tag.objects.filter(group_id=self.group_id_str_1).values_list("id", flat=True)
         parent_qs = Tag.objects.filter(children__id__in=child_ids).distinct().order_by("name")
         self.assertSequenceEqual(parent_qs, [self.t1])
 
     def test_filter_parent_by_children_values_obj(self):
-        """Query to select parents of children with specific ObjectId group_id"""
+        """Query to select parents of children with specific ObjectId group_id."""
         child_ids = Tag.objects.filter(group_id=self.group_id_obj_1).values_list("id", flat=True)
         parent_qs = Tag.objects.filter(children__id__in=child_ids).distinct().order_by("name")
         self.assertSequenceEqual(parent_qs, [self.t1])
 
     def test_filter_group_id_union_with_str(self):
-        """Combine queries using union with string values"""
+        """Combine queries using union with string values."""
         qs_a = Tag.objects.filter(group_id=self.group_id_str_1)
         qs_b = Tag.objects.filter(group_id=self.group_id_str_2)
         union_qs = qs_a.union(qs_b).order_by("name")
         self.assertSequenceEqual(union_qs, [self.t3, self.t4])
 
     def test_filter_group_id_union_with_obj(self):
-        """Combine queries using union with ObjectId values"""
+        """Combine queries using union with ObjectId values."""
         qs_a = Tag.objects.filter(group_id=self.group_id_obj_1)
         qs_b = Tag.objects.filter(group_id=self.group_id_obj_2)
         union_qs = qs_a.union(qs_b).order_by("name")