django-multisite2 2.1.1__py3-none-any.whl

multisite/models/managers.py

@@ -0,0 +1,196 @@
+from __future__ import annotations
+
+import operator
+from functools import reduce
+from typing import TYPE_CHECKING
+
+from django.contrib.sites import managers
+from django.core.exceptions import FieldDoesNotExist, ValidationError
+from django.core.validators import validate_ipv4_address
+from django.db import models
+from django.db.models import Q
+from django.db.models.constants import LOOKUP_SEP
+
+from ..exceptions import MultisiteInvalidHostError
+
+if TYPE_CHECKING:
+    from django.db.models import QuerySet
+
+    from .alias import Alias
+
+__all__ = [
+    "AliasManager",
+    "CanonicalAliasManager",
+    "NotCanonicalAliasManager",
+    "SpanningCurrentSiteManager",
+]
+
+
+class AliasManager(models.Manager):
+    """Manager for all Aliases."""
+
+    use_in_migrations = True
+
+    def get_queryset(self) -> QuerySet[Alias]:
+        return super().get_queryset().select_related("site")
+
+    def resolve(self, host: str, port: str | None = None) -> list[str] | None:
+        """Returns the Alias that best matches ``host`` and
+        ``port``, or None.
+
+        ``host`` is a hostname like ``'example.com'``.
+        ``port`` is a port number like 8000, or None.
+
+        Attempts to first match by 'host:port' against
+        Alias.domain. If that fails, it will try to match the bare
+        'host' with no port number.
+
+        All comparisons are done case-insensitively.
+        """
+        domains = self._expand_netloc(host=host, port=port)
+        q: Q = reduce(operator.or_, (Q(domain__iexact=d) for d in domains))
+        aliases = dict((a.domain, a) for a in self.get_queryset().filter(q))
+        for domain in domains:
+            try:
+                return aliases[domain]
+            except KeyError:
+                pass
+        return None
+
+    @classmethod
+    def _expand_netloc(cls, host: str, port: str | None = None) -> list[str]:
+        """Returns a list of possible domain expansions for ``host``
+        and ``port``.
+
+        ``host`` is a hostname like ``'example.com'``.
+        ``port`` is a port number like 8000, or None.
+
+        Expansions are ordered from highest to lowest preference and may
+        include wildcards. Examples::
+
+        >>> AliasManager._expand_netloc('www.example.com')
+        ['www.example.com', '*.example.com', '*.com', '*']
+
+        >>> AliasManager._expand_netloc('www.example.com', 80)
+        ['www.example.com:80', 'www.example.com',
+         '*.example.com:80', '*.example.com',
+         '*.com:80', '*.com',
+         '*:80', '*']
+        """
+        if not host:
+            raise MultisiteInvalidHostError("Invalid host: %s" % host)
+        try:
+            validate_ipv4_address(host)
+        except ValidationError:
+            # Not an IP address
+            bits = host.split(".")
+        else:
+            bits = [host]
+        result = []
+        for i in range(0, (len(bits) + 1)):
+            if i == 0:
+                host = ".".join(bits[i:])
+            else:
+                host = ".".join(["*"] + bits[i:])
+            if port:
+                result.append("%s:%s" % (host, port))
+            result.append(host)
+        return result
+
+
+class CanonicalAliasManager(models.Manager):
+    """Manager for Alias objects where is_canonical == 1."""
+
+    use_in_migrations = True
+
+    def get_queryset(self) -> QuerySet[Alias]:
+        queryset = super().get_queryset()
+        return queryset.filter(is_canonical=1)
+
+
+class NotCanonicalAliasManager(models.Manager):
+    """Manager for Aliases where is_canonical != 1."""
+
+    use_in_migrations = True
+
+    def get_queryset(self) -> QuerySet[Alias]:
+        queryset = super().get_queryset()
+        return queryset.exclude(is_canonical=1)
+
+
+class SpanningCurrentSiteManager(managers.CurrentSiteManager):
+    """Unlike ``django.contrib.sites.managers.CurrentSiteManager``,
+    this CurrentSiteManager can span multiple related models by using
+    the django filtering syntax, namely foo__bar__baz__site.
+
+    For example, let's say you have a model called Layer, which has
+    a field called family, which points to a model called LayerFamily,
+    which in turn has a field called site pointing to a
+    django.contrib.sites Site model. On Layer, add the following
+    manager:
+
+        on_site = SpanningCurrentSiteManager("family__site")
+
+    and it will do the proper thing.
+    """
+
+    def _validate_field_name(self):
+        """Given the field identifier, goes down the chain to check that
+        each specified field
+            a) exists,
+            b) is of type ForeignKey or ManyToManyField
+
+        If no field name is specified when instantiating
+        SpanningCurrentSiteManager, it tries to find either 'site' or
+        'sites' as the site link, much like CurrentSiteManager does.
+        """
+        if self._CurrentSiteManager__field_name is None:
+            # Guess at field name
+            field_names = self.model._meta.get_all_field_names()
+            for potential_name in ["site", "sites"]:
+                if potential_name in field_names:
+                    self._CurrentSiteManager__field_name = potential_name
+                    break
+            else:
+                raise ValueError(
+                    f"{self.__class__.__name__} couldn't find a field named either 'site' or 'sites' "
+                    f"in {self.model._meta.object_name}."
+                )
+
+        field_name_chain = self._CurrentSiteManager__field_name.split(LOOKUP_SEP)
+        model = self.model
+
+        for field_name in field_name_chain:
+            # Throws an exception if anything goes bad
+            self.validate_single_field_name(model, field_name)
+            model = self.get_related_model(model, field_name)
+
+        # If we get this far without an exception, everything is good
+        self._CurrentSiteManager__is_validated = True
+
+    @staticmethod
+    def validate_single_field_name(model, field_name) -> None:
+        """Checks if the given field_name can be used to make a link
+        between a model and a site.
+
+        If anything is wrong, will raise an appropriate exception,
+        because that is what CurrentSiteManager expects.
+        """
+        try:
+            field = model._meta.get_field(field_name)
+            if not isinstance(field, (models.ForeignKey, models.ManyToManyField)):
+                raise TypeError(f"Field {field_name} must be a ForeignKey or ManyToManyField.")
+        except FieldDoesNotExist:
+            raise ValueError(
+                f"Couldn't find a field named {field_name} in {model._meta.object_name}."
+            )
+
+    @staticmethod
+    def get_related_model(model, field_name) -> models.Model:
+        """Given a model and the name of a ForeignKey or ManyToManyField column
+        as a string, returns the associated model.
+        """
+        try:
+            return model._meta.get_field(field_name).remote_field.model
+        except AttributeError:
+            return model._meta.get_field(field_name).related_model

multisite/models/signals.py

@@ -0,0 +1,36 @@
+from django.contrib.sites.models import Site
+from django.core.exceptions import ObjectDoesNotExist
+from django.db import connections, router
+from django.db.models.signals import post_save, pre_save
+from django.dispatch import receiver
+
+from multisite.utils import create_or_sync_alias_from_site
+
+
+@receiver(pre_save, sender=Site, weak=False, dispatch_uid="site_domain_changed_hook")
+def pre_save_site_domain_changed(sender, instance, raw, *args, **kwargs):
+    """Updates canonical Alias object if Site.domain has changed."""
+    if not raw and instance.pk is not None:
+        try:
+            original = sender.objects.get(pk=instance.pk)
+        except ObjectDoesNotExist:
+            pass
+        else:
+            # Update Alias.domain to match site
+            if original.domain != instance.domain:
+                create_or_sync_alias_from_site(site=instance)
+
+
+@receiver(post_save, sender=Site, weak=False, dispatch_uid="site_created_hook")
+def post_save_site_created(sender, instance, raw, created, *args, **kwargs):
+    """Creates canonical Alias object for a new Site."""
+    if not raw and created:
+        # When running create_default_site() because of post_syncdb,
+        # don't try to sync before the db_table has been created.
+        using = router.db_for_write(sender)
+        tables = connections[using].introspection.table_names()
+        if sender._meta.db_table not in tables:
+            pass
+        else:
+            # Update Alias.domain to match site
+            create_or_sync_alias_from_site(site=instance)

multisite/models/validators.py

@@ -0,0 +1,14 @@
+from django.core.exceptions import ValidationError
+
+__all__ = ["validate_1_or_none"]
+
+
+def validate_1_or_none(value: bool) -> None:
+    """Raises ValidationError if value is not int(1) or None."""
+    if value not in [1, None]:
+        raise ValidationError("%r must be 1 or None" % value)
+
+
+def validate_true_or_none(value: bool) -> None:
+    # leave for old migrations
+    pass

multisite/tests/get_test_allowed_hosts.py

@@ -0,0 +1,14 @@
+def get_test_allowed_hosts(*extra, replace=None):
+    if replace:
+        allowed_hosts = []
+    else:
+        allowed_hosts = [
+            ".extrahost.com",
+            "app.test1.example.com",
+            "app.test2.example.com",
+            "example.com",
+            "new.app.test3.example.com",
+            "test.example.com",
+        ]
+    allowed_hosts.extend(extra)
+    return allowed_hosts

multisite/tests/get_test_http_response.py

@@ -0,0 +1,13 @@
+from typing import Callable, Type
+
+from django.http import HttpResponse
+
+
+def get_test_http_response(*cookies) -> Callable:
+    def http_response(request) -> HttpResponse:
+        response = HttpResponse()
+        for cookie in cookies:
+            response.set_cookie(**cookie)
+        return response
+
+    return http_response

multisite/tests/hosts.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+from django.utils.functional import SimpleLazyObject, empty
+
+__all__ = ["ALLOWED_HOSTS", "AllowedHosts"]
+
+_wrapped_default = empty
+
+
+def get_multisite_extra_hosts():
+    from django.conf import settings
+
+    return getattr(settings, "MULTISITE_EXTRA_HOSTS", [])
+
+
+class IterableLazyObject(SimpleLazyObject):
+    _wrapped_default = globals()["_wrapped_default"]
+
+    def __iter__(self):
+        if self._wrapped is self._wrapped_default:
+            self._setup()
+        return self._wrapped.__iter__()
+
+
+class AllowedHosts(object):
+    alias_model = None
+
+    def __init__(self):
+        self.extra_hosts = get_multisite_extra_hosts()
+        if self.alias_model is None:
+            from multisite.models import Alias
+
+            self.alias_model = Alias
+
+    def __iter__(self):
+        # Yielding extra hosts before actual hosts because there might be
+        # wild cards in there that would prevent us from doing a database
+        # query every time.
+        for host in self.extra_hosts:
+            yield host
+
+        for host in self.alias_model.objects.values_list("domain"):
+            yield host[0]
+
+
+ALLOWED_HOSTS = IterableLazyObject(lambda: AllowedHosts())

multisite/tests/test_settings.py

@@ -0,0 +1,23 @@
+from multisite import SiteID
+
+SILENCED_SYSTEM_CHECKS = ["sites.E101"]
+SECRET_KEY = "iufoj=mibkpdz*%bob952x(%49rqgv8gg45k36kjcg76&-y5=!"  # nosec B105
+SITE_ID = SiteID(default=1)
+DATABASES = {
+    "default": {
+        "ENGINE": "django.db.backends.sqlite3",
+        "NAME": ":memory:",
+    }
+}
+
+INSTALLED_APPS = [
+    # "django.contrib.auth",
+    # "django.contrib.contenttypes",
+    "django.contrib.sites",
+    "multisite",
+    "multisite_app",
+]
+MIDDLEWARE = [
+    "multisite.middleware.DynamicSiteMiddleware",
+    "django.contrib.sites.middleware.CurrentSiteMiddleware",
+]

multisite/tests/tests/request_factory.py

@@ -0,0 +1,12 @@
+from django.test.client import RequestFactory as DjangoRequestFactory
+
+
+class RequestFactory(DjangoRequestFactory):
+    def __init__(self, host):
+        super().__init__()
+        self.host = host
+
+    def get(self, path, data={}, host=None, **extra):
+        if host is None:
+            host = self.host
+        return super().get(path=path, data=data, HTTP_HOST=host, **extra)

multisite/tests/tests/test_alias.py

@@ -0,0 +1,272 @@
+from django.contrib.sites.models import Site
+from django.core.exceptions import MultipleObjectsReturned, ValidationError
+from django.test import TestCase, tag
+
+from multisite.exceptions import MultisiteInvalidHostError
+from multisite.models import Alias
+from multisite.utils import (
+    create_or_sync_alias_from_site,
+    create_or_sync_canonical_from_all_sites,
+    create_or_sync_missing_canonical_from_site_domain,
+    sync_blank_domain,
+    sync_canonical_from_site_domain,
+)
+
+
+class AliasTest(TestCase):
+    def setUp(self):
+        Alias.objects.all().delete()
+        Site.objects.all().delete()
+
+    def test_create(self):
+        Site.objects.create()  # site0
+        site1 = Site.objects.create(domain="1.example")
+        site2 = Site.objects.create(domain="2.example")
+        # Missing site
+        self.assertRaises(ValidationError, Alias.objects.create)
+        self.assertRaises(ValidationError, Alias.objects.create, domain="0.example")
+        # Valid
+        self.assertTrue(Alias.objects.create(domain="1a.example", site=site1))
+        # Duplicate domain
+        self.assertRaises(
+            ValidationError, Alias.objects.create, domain=site1.domain, site=site1
+        )
+        self.assertRaises(
+            ValidationError, Alias.objects.create, domain=site2.domain, site=site1
+        )
+        self.assertRaises(
+            ValidationError, Alias.objects.create, domain="1a.example", site=site1
+        )
+        # Duplicate domains, case-sensitivity
+        self.assertRaises(
+            ValidationError, Alias.objects.create, domain="1A.EXAMPLE", site=site2
+        )
+        self.assertRaises(
+            ValidationError, Alias.objects.create, domain="2.EXAMPLE", site=site2
+        )
+        # Duplicate is_canonical
+        site1.domain = "1b.example"
+        self.assertRaises(
+            ValidationError,
+            Alias.objects.create,
+            domain=site1.domain,
+            site=site1,
+            is_canonical=1,
+        )
+        # Invalid is_canonical
+        self.assertRaises(
+            ValidationError,
+            Alias.objects.create,
+            domain=site1.domain,
+            site=site1,
+            is_canonical=0,
+        )
+
+    def test_repr(self):
+        site = Site.objects.create(domain="example.com")
+        self.assertEqual(
+            repr(Alias.objects.get(site=site)),
+            "<Alias: %(domain)s -> %(domain)s>" % site.__dict__,
+        )
+
+    @tag("1")
+    def test_managers(self):
+        site = Site.objects.create(domain="example.com")
+        Alias.objects.create(site=site, domain="example.org")
+        self.assertEqual(
+            set(Alias.objects.values_list("domain", flat=True)),
+            set(["example.com", "example.org"]),
+        )
+        self.assertEqual(
+            set(Alias.canonical.values_list("domain", flat=True)), set(["example.com"])
+        )
+        self.assertEqual(
+            set(Alias.aliases.values_list("domain", flat=True)), set(["example.org"])
+        )
+
+    def test_sync_canonical_from_site_domain(self):
+        # Create Sites with Aliases
+        Site.objects.create()
+        site1 = Site.objects.create(domain="1.example.com")
+        site2 = Site.objects.create(domain="2.example.com")
+        # Create Site without triggering signals
+        site3 = Site(domain="3.example.com")
+        site3.save_base(raw=True)
+        self.assertEqual(
+            set(Alias.objects.values_list("domain", flat=True)),
+            set([site1.domain, site2.domain]),
+        )
+        # Sync existing
+        site1.domain = "1.example.org"
+        site1.save_base(raw=True)
+        site2.domain = "2.example.org"
+        site2.save_base(raw=True)
+        sync_canonical_from_site_domain()
+        self.assertEqual(
+            set(Alias.objects.values_list("domain", flat=True)),
+            set([site1.domain, site2.domain]),
+        )
+        # Sync with filter
+        site1.domain = "1.example.net"
+        site1.save_base(raw=True)
+        site2.domain = "2.example.net"
+        site2.save_base(raw=True)
+        sync_canonical_from_site_domain(site__domain=site1.domain)
+        self.assertEqual(
+            set(Alias.objects.values_list("domain", flat=True)),
+            set([site1.domain, "2.example.org"]),
+        )
+
+    def test_sync_missing(self):
+        Site.objects.create()
+        site1 = Site.objects.create(domain="1.example.com")
+        # Update site1 without triggering signals
+        site1.domain = "1.example.org"
+        site1.save_base(raw=True)
+        # Create site2 without triggering signals
+        site2 = Site(domain="2.example.org")
+        site2.save_base(raw=True)
+        # Only site2 should be updated
+        create_or_sync_missing_canonical_from_site_domain()
+        self.assertEqual(
+            set(Alias.objects.values_list("domain", flat=True)),
+            set(["1.example.com", site2.domain]),
+        )
+
+    def test_sync_all(self):
+        Site.objects.create()
+        site1 = Site.objects.create(domain="1.example.com")
+        # Update site1 without triggering signals
+        site1.domain = "1.example.org"
+        site1.save_base(raw=True)
+        # Create site2 without triggering signals
+        site2 = Site(domain="2.example.org")
+        site2.save_base(raw=True)
+        # Sync all
+        create_or_sync_canonical_from_all_sites()
+        self.assertEqual(
+            set(Alias.objects.values_list("domain", flat=True)),
+            set([site1.domain, site2.domain]),
+        )
+
+    def test_sync(self):
+        # Create Site without triggering signals
+        site = Site(domain="example.com")
+        site.save_base(raw=True)
+        # Insert Alias
+        self.assertFalse(Alias.objects.filter(site=site).exists())
+        create_or_sync_alias_from_site(site=site)
+        self.assertEqual(Alias.objects.get(site=site).domain, site.domain)
+        # Idempotent sync_alias
+        create_or_sync_alias_from_site(site=site)
+        self.assertEqual(Alias.objects.get(site=site).domain, site.domain)
+        # Duplicate force_insert
+        self.assertRaises(
+            ValidationError, create_or_sync_alias_from_site, site=site, force_insert=True
+        )
+        # Update Alias
+        site.domain = "example.org"
+        create_or_sync_alias_from_site(site=site)
+        self.assertEqual(Alias.objects.get(site=site).domain, site.domain)
+        # Clear domain
+        site.domain = ""
+        create_or_sync_alias_from_site(site=site)
+        self.assertFalse(Alias.objects.filter(site=site).exists())
+
+    def test_sync_blank_domain(self):
+        # Create Site
+        site = Site.objects.create(domain="example.com")
+        # Without clearing domain
+        self.assertRaises(ValueError, sync_blank_domain, site=site)
+        # With an extra Alias
+        site.domain = ""
+        alias = Alias.objects.create(site=site, domain="example.org")
+        self.assertRaises(MultipleObjectsReturned, sync_blank_domain, site=site)
+        # With a blank site
+        alias.delete()
+        sync_blank_domain(site=site)
+        self.assertFalse(Alias.objects.filter(site=site).exists())
+
+    def test_hooks(self):
+        # Create empty Site
+        Site.objects.create()
+        self.assertFalse(Alias.objects.filter(domain="").exists())
+        # Create Site
+        site = Site.objects.create(domain="example.com")
+        alias = Alias.objects.get(site=site)
+        self.assertEqual(alias.domain, site.domain)
+        self.assertTrue(alias.is_canonical)
+        # Create a non-canonical alias
+        Alias.objects.create(site=site, domain="example.info")
+        # Change Site to another domain name
+        site.domain = "example.org"
+        site.save()
+        self.assertEqual(Alias.canonical.get(site=site).domain, site.domain)
+        self.assertEqual(Alias.aliases.get(site=site).domain, "example.info")
+        # Change Site to an empty domain name
+        site.domain = ""
+        self.assertRaises(MultipleObjectsReturned, site.save)
+
+        Alias.aliases.all().delete()
+        Site.objects.get(domain="").delete()  # domain is unique in Django1.9
+        site.save()
+        self.assertFalse(Alias.objects.filter(site=site).exists())
+
+        # Change Site from an empty domain name
+        site.domain = "example.net"
+        site.save()
+        site.refresh_from_db()
+        self.assertEqual(Alias.canonical.get(site=site).domain, site.domain)
+
+        # Delete Site, which deletes Alias
+        site.delete()
+        self.assertFalse(Alias.objects.filter(site__domain="example.net").exists())
+
+    def test_expand_netloc(self):
+        _expand_netloc = Alias.objects._expand_netloc
+        self.assertRaises(MultisiteInvalidHostError, _expand_netloc, "")
+        self.assertRaises(MultisiteInvalidHostError, _expand_netloc, "", 8000)
+        self.assertEqual(
+            _expand_netloc("testserver", 8000),
+            ["testserver:8000", "testserver", "*:8000", "*"],
+        )
+        self.assertEqual(_expand_netloc("testserver"), ["testserver", "*"])
+        self.assertEqual(
+            _expand_netloc("example.com", 8000),
+            ["example.com:8000", "example.com", "*.com:8000", "*.com", "*:8000", "*"],
+        )
+        self.assertEqual(_expand_netloc("example.com"), ["example.com", "*.com", "*"])
+        self.assertEqual(
+            _expand_netloc("www.example.com", 8000),
+            [
+                "www.example.com:8000",
+                "www.example.com",
+                "*.example.com:8000",
+                "*.example.com",
+                "*.com:8000",
+                "*.com",
+                "*:8000",
+                "*",
+            ],
+        )
+        self.assertEqual(
+            _expand_netloc("www.example.com"),
+            ["www.example.com", "*.example.com", "*.com", "*"],
+        )
+
+    def test_resolve(self):
+        site = Site.objects.create(domain="example.com")
+        alias = Alias.objects.get(domain="example.com")
+        # *.example.com
+        self.assertEqual(Alias.objects.resolve("www.example.com"), None)
+        self.assertEqual(Alias.objects.resolve("www.dev.example.com"), None)
+
+        alias = Alias.objects.create(site=site, domain="*.example.com")
+        self.assertEqual(Alias.objects.resolve("www.example.com"), alias)
+        self.assertEqual(Alias.objects.resolve("www.dev.example.com"), alias)
+        # *
+        self.assertEqual(Alias.objects.resolve("example.net"), None)
+
+        alias = Alias.objects.create(site=site, domain="*")
+        self.assertEqual(Alias.objects.resolve("example.net"), alias)
+        self.assertEqual(Alias.objects.resolve("blah"), alias)