Merge branch 'main' into INTPYTHON-348

Author: aclark4life

.github/workflows/runtests.py

@@ -0,0 +1,79 @@
+#!/usr/bin/env python
+import os
+import pathlib
+import sys
+
+test_apps = [
+    "admin_filters",
+    "aggregation",
+    "aggregation_regress",
+    "annotations",
+    "auth_tests.test_models.UserManagerTestCase",
+    "backends",
+    "basic",
+    "bulk_create",
+    "custom_pk",
+    "dates",
+    "datetimes",
+    "db_functions",
+    "dbshell_",
+    "defer",
+    "defer_regress",
+    "delete",
+    "delete_regress",
+    "empty",
+    "expressions",
+    "expressions_case",
+    "force_insert_update",
+    "from_db_value",
+    "generic_relations",
+    "generic_relations_regress",
+    "introspection",
+    "known_related_objects",
+    "lookup",
+    "m2m_and_m2o",
+    "m2m_intermediary",
+    "m2m_multiple",
+    "m2m_recursive",
+    "m2m_regress",
+    "m2m_signals",
+    "m2m_through",
+    "m2m_through_regress",
+    "m2o_recursive",
+    "many_to_many",
+    "many_to_one",
+    "many_to_one_null",
+    "migrations",
+    "model_fields",
+    "model_fields_",
+    "model_forms",
+    "model_formsets",
+    "model_inheritance_regress",
+    "mutually_referential",
+    "nested_foreign_keys",
+    "null_fk",
+    "null_fk_ordering",
+    "null_queries",
+    "one_to_one",
+    "or_lookups",
+    "ordering",
+    "queries",
+    "queries_",
+    "schema",
+    "select_related",
+    "select_related_onetoone",
+    "select_related_regress",
+    "sessions_tests",
+    "timezones",
+    "update",
+    "xor_lookups",
+]
+runtests = pathlib.Path(__file__).parent.resolve() / "runtests.py"
+run_tests_cmd = f"python3 {runtests} %s --settings mongodb_settings -v 2"
+
+shouldFail = False
+for app_name in test_apps:
+    res = os.system(run_tests_cmd % app_name)  # noqa: S605
+    if res != 0:
+        shouldFail = True
+sys.exit(1 if shouldFail else 0)

.github/workflows/test-python.yml

@@ -44,70 +44,11 @@ jobs:
           pip3 install -r requirements/py3.txt
       - name: Copy the test settings file
         run: cp .github/workflows/mongodb_settings.py django_repo/tests/
+      - name: Copy the test runner file
+        run: cp .github/workflows/runtests.py django_repo/tests/runtests_.py
       - name: Start MongoDB
         uses: supercharge/[email protected]
         with:
           mongodb-version: 5.0
       - name: Run tests
-        run: >
-          python3 django_repo/tests/runtests.py --settings mongodb_settings -v 2
-          admin_filters
-          aggregation
-          aggregation_regress
-          annotations
-          auth_tests.test_models.UserManagerTestCase
-          backends
-          basic
-          bulk_create
-          custom_pk
-          dates
-          datetimes
-          db_functions
-          dbshell_
-          delete
-          delete_regress
-          empty
-          expressions
-          expressions_case
-          defer
-          defer_regress
-          force_insert_update
-          from_db_value
-          generic_relations
-          generic_relations_regress
-          introspection
-          known_related_objects
-          lookup
-          m2m_and_m2o
-          m2m_intermediary
-          m2m_multiple
-          m2m_recursive
-          m2m_regress
-          m2m_signals
-          m2m_through
-          m2m_through_regress
-          m2o_recursive
-          many_to_many
-          many_to_one
-          many_to_one_null
-          migrations
-          model_fields
-          model_forms
-          model_inheritance_regress
-          mutually_referential
-          nested_foreign_keys
-          null_fk
-          null_fk_ordering
-          null_queries
-          one_to_one
-          ordering
-          or_lookups
-          queries
-          schema
-          select_related
-          select_related_onetoone
-          select_related_regress
-          sessions_tests
-          timezones
-          update
-          xor_lookups
+        run: python3 django_repo/tests/runtests_.py

django_mongodb/base.py

@@ -1,5 +1,6 @@
+import contextlib
+
 from django.db.backends.base.base import BaseDatabaseWrapper
-from django.db.backends.signals import connection_created
 from pymongo.collection import Collection
 from pymongo.mongo_client import MongoClient
 
@@ -128,11 +129,6 @@ def _isnull_operator(a, b):
     introspection_class = DatabaseIntrospection
     ops_class = DatabaseOperations
 
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        self.connected = False
-        del self.connection
-
     def get_collection(self, name, **kwargs):
         collection = Collection(self.database, name, **kwargs)
         if self.queries_logged:
@@ -145,44 +141,45 @@ def get_database(self):
         return self.database
 
     def __getattr__(self, attr):
-        """
-        Connect to the database the first time `connection` or `database` are
-        accessed.
-        """
-        if attr in ["connection", "database"]:
-            assert not self.connected
-            self._connect()
+        """Connect to the database the first time `database` is accessed."""
+        if attr == "database":
+            if self.connection is None:
+                self.connect()
             return getattr(self, attr)
         raise AttributeError(attr)
 
-    def _connect(self):
-        settings_dict = self.settings_dict
-        self.connection = MongoClient(
-            host=settings_dict["HOST"] or None,
-            port=int(settings_dict["PORT"] or 27017),
-            username=settings_dict.get("USER"),
-            password=settings_dict.get("PASSWORD"),
-            **settings_dict["OPTIONS"],
-        )
-        db_name = settings_dict["NAME"]
+    def init_connection_state(self):
+        db_name = self.settings_dict["NAME"]
         if db_name:
             self.database = self.connection[db_name]
+        super().init_connection_state()
+
+    def get_connection_params(self):
+        settings_dict = self.settings_dict
+        return {
+            "host": settings_dict["HOST"] or None,
+            "port": int(settings_dict["PORT"] or 27017),
+            "username": settings_dict.get("USER"),
+            "password": settings_dict.get("PASSWORD"),
+            **settings_dict["OPTIONS"],
+        }
 
-        self.connected = True
-        connection_created.send(sender=self.__class__, connection=self)
+    def get_new_connection(self, conn_params):
+        return MongoClient(**conn_params)
 
     def _commit(self):
         pass
 
     def _rollback(self):
         pass
 
+    def set_autocommit(self, autocommit, force_begin_transaction_with_broken_autocommit=False):
+        pass
+
     def close(self):
-        if self.connected:
-            self.connection.close()
-            del self.connection
+        super().close()
+        with contextlib.suppress(AttributeError):
             del self.database
-            self.connected = False
 
     def cursor(self):
         return Cursor()

django_mongodb/compiler.py

@@ -386,9 +386,9 @@ def build_query(self, columns=None):
             try:
                 expr = where.as_mql(self, self.connection) if where else {}
             except FullResultSet:
-                query.mongo_query = {}
+                query.match_mql = {}
             else:
-                query.mongo_query = {"$expr": expr}
+                query.match_mql = {"$expr": expr}
         if extra_fields:
             query.extra_fields = self.get_project_fields(extra_fields, force_expression=True)
         query.subqueries = self.subqueries
@@ -722,7 +722,7 @@ def execute_sql(self, result_type):
                 prepared = prepared.as_mql(self, self.connection)
             values[field.column] = prepared
         try:
-            criteria = self.build_query().mongo_query
+            criteria = self.build_query().match_mql
         except EmptyResultSet:
             return 0
         is_empty = not bool(values)

django_mongodb/features.py

@@ -3,6 +3,7 @@
 
 
 class DatabaseFeatures(BaseDatabaseFeatures):
+    minimum_database_version = (5, 0)
     allow_sliced_subqueries_with_in = False
     allows_multiple_constraints_on_same_fields = False
     can_create_inline_fk = False
@@ -71,7 +72,6 @@ class DatabaseFeatures(BaseDatabaseFeatures):
         "backends.tests.BackendTestCase.test_is_usable_after_database_disconnects",
         # Connection creation doesn't follow the usual Django API.
         "backends.tests.ThreadTests.test_pass_connection_between_threads",
-        "backends.tests.ThreadTests.test_closing_non_shared_connections",
         "backends.tests.ThreadTests.test_default_connection_thread_local",
         # Union as subquery is not mapping the parent parameter and collections:
         # https://github.com/mongodb-labs/django-mongodb/issues/156

django_mongodb/fields/auto.py

@@ -15,6 +15,14 @@ def __init__(self, *args, **kwargs):
         kwargs["db_column"] = "_id"
         super().__init__(*args, **kwargs)
 
+    def deconstruct(self):
+        name, path, args, kwargs = super().deconstruct()
+        if self.db_column == "_id":
+            del kwargs["db_column"]
+        if path.startswith("django_mongodb.fields.auto"):
+            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
@@ -43,11 +51,14 @@ def to_python(self, value):
         try:
             return ObjectId(value)
         except errors.InvalidId:
-            raise exceptions.ValidationError(
-                self.error_messages["invalid"],
-                code="invalid",
-                params={"value": value},
-            ) from None
+            try:
+                return int(value)
+            except ValueError:
+                raise exceptions.ValidationError(
+                    self.error_messages["invalid"],
+                    code="invalid",
+                    params={"value": value},
+                ) from None
 
     @cached_property
     def validators(self):

django_mongodb/query.py

@@ -47,14 +47,9 @@ class MongoQuery:
 
     def __init__(self, compiler):
         self.compiler = compiler
-        self.connection = compiler.connection
-        self.ops = compiler.connection.ops
         self.query = compiler.query
-        self._negated = False
         self.ordering = []
-        self.collection = self.compiler.collection
-        self.collection_name = self.compiler.collection_name
-        self.mongo_query = getattr(compiler.query, "raw_query", {})
+        self.match_mql = {}
         self.subqueries = None
         self.lookup_pipeline = None
         self.project_fields = None
@@ -66,31 +61,31 @@ def __init__(self, compiler):
         self.subquery_lookup = None
 
     def __repr__(self):
-        return f"<MongoQuery: {self.mongo_query!r} ORDER {self.ordering!r}>"
+        return f"<MongoQuery: {self.match_mql!r} ORDER {self.ordering!r}>"
 
     @wrap_database_errors
     def delete(self):
         """Execute a delete query."""
         if self.compiler.subqueries:
             raise NotSupportedError("Cannot use QuerySet.delete() when a subquery is required.")
-        return self.collection.delete_many(self.mongo_query).deleted_count
+        return self.compiler.collection.delete_many(self.match_mql).deleted_count
 
     @wrap_database_errors
     def get_cursor(self):
         """
         Return a pymongo CommandCursor that can be iterated on to give the
         results of the query.
         """
-        return self.collection.aggregate(self.get_pipeline())
+        return self.compiler.collection.aggregate(self.get_pipeline())
 
     def get_pipeline(self):
         pipeline = []
         if self.lookup_pipeline:
             pipeline.extend(self.lookup_pipeline)
         for query in self.subqueries or ():
             pipeline.extend(query.get_pipeline())
-        if self.mongo_query:
-            pipeline.append({"$match": self.mongo_query})
+        if self.match_mql:
+            pipeline.append({"$match": self.match_mql})
         if self.aggregation_pipeline:
             pipeline.extend(self.aggregation_pipeline)
         if self.project_fields:
@@ -294,7 +289,7 @@ def where_node(self, compiler, connection):
     if len(children_mql) == 1:
         mql = children_mql[0]
     elif len(children_mql) > 1:
-        mql = {operator: children_mql} if children_mql else {}
+        mql = {operator: children_mql}
     else:
         mql = {}
 

tests/model_fields_/__init__.py

@@ -0,0 +1,16 @@
+from django.test import SimpleTestCase
+
+from django_mongodb.fields import ObjectIdAutoField
+
+
+class MethodTests(SimpleTestCase):
+    def test_deconstruct(self):
+        field = ObjectIdAutoField()
+        name, path, args, kwargs = field.deconstruct()
+        self.assertEqual(path, "django_mongodb.fields.ObjectIdAutoField")
+        self.assertEqual(args, [])
+        self.assertEqual(kwargs, {"primary_key": True})
+
+    def test_to_python(self):
+        f = ObjectIdAutoField()
+        self.assertEqual(f.to_python("1"), 1)