Merge branch 'main' into mdb-8-auth-ssl-tests

Author: Jibola

.github/workflows/release-python.yml

@@ -76,6 +76,11 @@ jobs:
         with:
           name: all-dist-${{ github.run_id }}
           path: dist/
+      - name: Publish package distributions to TestPyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          repository-url: https://test.pypi.org/legacy/
+          skip-existing: true
       - name: Publish package distributions to PyPI
         if: startsWith(inputs.dry_run, 'false')
         uses: pypa/gh-action-pypi-publish@release/v1
@@ -108,5 +113,4 @@ jobs:
           silk_asset_group: ${{ env.SILK_ASSET_GROUP }}
           evergreen_project: ${{ env.EVERGREEN_PROJECT }}
           token: ${{ github.token }}
-          repository_url: https://test.pypi.org/legacy/
           dry_run: ${{ inputs.dry_run }}

django_mongodb_backend/fields/embedded_model.py

@@ -18,7 +18,18 @@ def __init__(self, embedded_model, *args, **kwargs):
         super().__init__(*args, **kwargs)
 
     def check(self, **kwargs):
+        from ..models import EmbeddedModel
+
         errors = super().check(**kwargs)
+        if not issubclass(self.embedded_model, EmbeddedModel):
+            return [
+                checks.Error(
+                    "Embedded models must be a subclass of "
+                    "django_mongodb_backend.models.EmbeddedModel.",
+                    obj=self,
+                    id="django_mongodb_backend.embedded_model.E002",
+                )
+            ]
         for field in self.embedded_model._meta.fields:
             if field.remote_field:
                 errors.append(
@@ -27,7 +38,7 @@ def check(self, **kwargs):
                         f"({self.embedded_model().__class__.__name__}.{field.name} "
                         f"is a {field.__class__.__name__}).",
                         obj=self,
-                        id="django_mongodb.embedded_model.E001",
+                        id="django_mongodb_backend.embedded_model.E001",
                     )
                 )
         return errors

django_mongodb_backend/managers.py

@@ -1,7 +1,37 @@
+from django.db import NotSupportedError
 from django.db.models.manager import BaseManager
 
 from .queryset import MongoQuerySet
 
 
 class MongoManager(BaseManager.from_queryset(MongoQuerySet)):
     pass
+
+
+class EmbeddedModelManager(BaseManager):
+    """
+    Prevent all queryset operations on embedded models since they don't have
+    their own collection.
+
+    Raise a helpful error message for some basic QuerySet methods. Subclassing
+    BaseManager means that other methods raise, e.g. AttributeError:
+    'EmbeddedModelManager' object has no attribute 'update_or_create'".
+    """
+
+    def all(self):
+        raise NotSupportedError("EmbeddedModels cannot be queried.")
+
+    def get(self, *args, **kwargs):
+        raise NotSupportedError("EmbeddedModels cannot be queried.")
+
+    def filter(self, *args, **kwargs):
+        raise NotSupportedError("EmbeddedModels cannot be queried.")
+
+    def create(self, **kwargs):
+        raise NotSupportedError("EmbeddedModels cannot be created.")
+
+    def update(self, *args, **kwargs):
+        raise NotSupportedError("EmbeddedModels cannot be updated.")
+
+    def delete(self):
+        raise NotSupportedError("EmbeddedModels cannot be deleted.")

django_mongodb_backend/models.py

@@ -0,0 +1,16 @@
+from django.db import NotSupportedError, models
+
+from .managers import EmbeddedModelManager
+
+
+class EmbeddedModel(models.Model):
+    objects = EmbeddedModelManager()
+
+    class Meta:
+        abstract = True
+
+    def delete(self, *args, **kwargs):
+        raise NotSupportedError("EmbeddedModels cannot be deleted.")
+
+    def save(self, *args, **kwargs):
+        raise NotSupportedError("EmbeddedModels cannot be saved.")

django_mongodb_backend/schema.py

@@ -10,6 +10,24 @@
 from .utils import OperationCollector
 
 
+def ignore_embedded_models(func):
+    """
+    Make a SchemaEditor method a no-op if model is an EmbeddedModel (unless
+    parent_model isn't None, in which case this is a valid recursive operation
+    such as adding an index on an embedded model's field).
+    """
+
+    def wrapper(self, model, *args, **kwargs):
+        parent_model = kwargs.get("parent_model")
+        from .models import EmbeddedModel
+
+        if issubclass(model, EmbeddedModel) and parent_model is None:
+            return
+        func(self, model, *args, **kwargs)
+
+    return wrapper
+
+
 class DatabaseSchemaEditor(BaseDatabaseSchemaEditor):
     def get_collection(self, name):
         if self.collect_sql:
@@ -22,6 +40,7 @@ def get_database(self):
         return self.connection.get_database()
 
     @wrap_database_errors
+    @ignore_embedded_models
     def create_model(self, model):
         self.get_database().create_collection(model._meta.db_table)
         self._create_model_indexes(model)
@@ -75,13 +94,15 @@ def _create_model_indexes(self, model, column_prefix="", parent_model=None):
         for index in model._meta.indexes:
             self.add_index(model, index, column_prefix=column_prefix, parent_model=parent_model)
 
+    @ignore_embedded_models
     def delete_model(self, model):
         # Delete implicit M2m tables.
         for field in model._meta.local_many_to_many:
             if field.remote_field.through._meta.auto_created:
                 self.delete_model(field.remote_field.through)
         self.get_collection(model._meta.db_table).drop()
 
+    @ignore_embedded_models
     def add_field(self, model, field):
         # Create implicit M2M tables.
         if field.many_to_many and field.remote_field.through._meta.auto_created:
@@ -103,6 +124,7 @@ def add_field(self, model, field):
         elif self._field_should_have_unique(field):
             self._add_field_unique(model, field)
 
+    @ignore_embedded_models
     def _alter_field(
         self,
         model,
@@ -149,6 +171,7 @@ def _alter_field(
         if not old_field_unique and new_field_unique:
             self._add_field_unique(model, new_field)
 
+    @ignore_embedded_models
     def remove_field(self, model, field):
         # Remove implicit M2M tables.
         if field.many_to_many and field.remote_field.through._meta.auto_created:
@@ -210,6 +233,7 @@ def _remove_model_indexes(self, model, column_prefix="", parent_model=None):
         for index in model._meta.indexes:
             self.remove_index(parent_model or model, index)
 
+    @ignore_embedded_models
     def alter_index_together(self, model, old_index_together, new_index_together, column_prefix=""):
         olds = {tuple(fields) for fields in old_index_together}
         news = {tuple(fields) for fields in new_index_together}
@@ -222,6 +246,7 @@ def alter_index_together(self, model, old_index_together, new_index_together, co
         for field_names in news.difference(olds):
             self._add_composed_index(model, field_names, column_prefix=column_prefix)
 
+    @ignore_embedded_models
     def alter_unique_together(
         self, model, old_unique_together, new_unique_together, column_prefix="", parent_model=None
     ):
@@ -249,6 +274,7 @@ def alter_unique_together(
                 model, constraint, parent_model=parent_model, column_prefix=column_prefix
             )
 
+    @ignore_embedded_models
     def add_index(
         self, model, index, *, field=None, unique=False, column_prefix="", parent_model=None
     ):
@@ -302,6 +328,7 @@ def _add_field_index(self, model, field, *, column_prefix=""):
         index.name = self._create_index_name(model._meta.db_table, [column_prefix + field.column])
         self.add_index(model, index, field=field, column_prefix=column_prefix)
 
+    @ignore_embedded_models
     def remove_index(self, model, index):
         if index.contains_expressions:
             return
@@ -355,6 +382,7 @@ def _remove_field_index(self, model, field, column_prefix=""):
             )
         collection.drop_index(index_names[0])
 
+    @ignore_embedded_models
     def add_constraint(self, model, constraint, field=None, column_prefix="", parent_model=None):
         if isinstance(constraint, UniqueConstraint) and self._unique_supported(
             condition=constraint.condition,
@@ -384,6 +412,7 @@ def _add_field_unique(self, model, field, column_prefix=""):
         constraint = UniqueConstraint(fields=[field.name], name=name)
         self.add_constraint(model, constraint, field=field, column_prefix=column_prefix)
 
+    @ignore_embedded_models
     def remove_constraint(self, model, constraint):
         if isinstance(constraint, UniqueConstraint) and self._unique_supported(
             condition=constraint.condition,
@@ -417,6 +446,7 @@ def _remove_field_unique(self, model, field, column_prefix=""):
             )
         self.get_collection(model._meta.db_table).drop_index(constraint_names[0])
 
+    @ignore_embedded_models
     def alter_db_table(self, model, old_db_table, new_db_table):
         if old_db_table == new_db_table:
             return

docs/Makefile

@@ -3,7 +3,7 @@
 
 # You can set these variables from the command line, and also
 # from the environment for the first two.
-SPHINXOPTS    ?=
+SPHINXOPTS    ?= -n
 SPHINXBUILD   ?= sphinx-build
 SOURCEDIR     = source
 BUILDDIR      = build

docs/make.bat

@@ -9,6 +9,7 @@ if "%SPHINXBUILD%" == "" (
 )
 set SOURCEDIR=source
 set BUILDDIR=build
+set SPHINXOPTS=-n
 
 %SPHINXBUILD% >NUL 2>NUL
 if errorlevel 9009 (

docs/source/embedded-models.rst

@@ -1,8 +1,8 @@
 Embedded models
 ===============
 
-Use :class:`~django_mongdob.fields.EmbeddedModelField` to structure your data
-using `embedded documents
+Use :class:`~django_mongodb_backend.fields.EmbeddedModelField` to structure
+your data using `embedded documents
 <https://www.mongodb.com/docs/manual/data-modeling/#embedded-data>`_.
 
 The basics
@@ -11,13 +11,14 @@ The basics
 Let's consider this example::
 
    from django_mongodb_backend.fields import EmbeddedModelField
+   from django_mongodb_backend.models import EmbeddedModel
 
    class Customer(models.Model):
        name = models.CharField(...)
        address = EmbeddedModelField("Address")
        ...
 
-   class Address(models.Model):
+   class Address(EmbeddedModel):
        ...
        city = models.CharField(...)
 

docs/source/fields.rst

@@ -222,8 +222,11 @@ Stores a model of type ``embedded_model``.
 
         This is a required argument.
 
-        Specifies the model class to embed. It can be either a concrete model
-        class or a :ref:`lazy reference <lazy-relationships>` to a model class.
+        Specifies the model class to embed. It must be a subclass of
+        :class:`django_mongodb_backend.models.EmbeddedModel`.
+
+        It can be either a concrete model class or a :ref:`lazy reference
+        <lazy-relationships>` to a model class.
 
         The embedded model cannot have relational fields
         (:class:`~django.db.models.ForeignKey`,
@@ -234,11 +237,12 @@ Stores a model of type ``embedded_model``.
 
             from django.db import models
             from django_mongodb_backend.fields import EmbeddedModelField
+            from django_mongodb_backend.models import EmbeddedModel
 
-            class Address(models.Model):
+            class Address(EmbeddedModel):
                 ...
 
-            class Author(models.Model):
+            class Author(EmbeddedModel):
                 address = EmbeddedModelField(Address)
 
             class Book(models.Model):

docs/source/index.rst

@@ -8,6 +8,7 @@ django-mongodb-backend 5.0.x documentation
    fields
    querysets
    forms
+   models
    embedded-models
 
 Indices and tables