django-multisite2 2.0.0__py3-none-any.whl

multisite/tests/tests/test_alias.py

@@ -0,0 +1,271 @@
+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__,
+        )
+
+    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)

multisite/tests/tests/test_contrib_site.py

@@ -0,0 +1,21 @@
+from django.conf import settings
+from django.contrib.sites.models import Site
+from django.test import TestCase, override_settings
+
+from multisite import SiteID
+
+
+@override_settings(
+    SITE_ID=SiteID(),
+    CACHE_SITES_KEY_PREFIX="__test__",
+)
+class TestContribSite(TestCase):
+    def setUp(self):
+        Site.objects.all().delete()
+        self.site = Site.objects.create(domain="example.com")
+        settings.SITE_ID.set(self.site.id)
+
+    def test_get_current_site(self):
+        current_site = Site.objects.get_current()
+        self.assertEqual(current_site, self.site)
+        self.assertEqual(current_site.id, settings.SITE_ID)

multisite/tests/tests/test_cookie_domain_middleware.py

@@ -0,0 +1,196 @@
+import tempfile
+
+from django.contrib.sites.models import Site
+from django.http import HttpResponse, SimpleCookie
+from django.test import TestCase, override_settings
+
+from multisite.exceptions import MultisiteCookieDomainDepthError
+from multisite.middleware import CookieDomainMiddleware
+
+from ..get_test_allowed_hosts import get_test_allowed_hosts
+from ..get_test_http_response import get_test_http_response
+from .request_factory import RequestFactory
+
+
+@override_settings(
+    MULTISITE_COOKIE_DOMAIN_DEPTH=0,
+    MULTISITE_PUBLIC_SUFFIX_LIST_CACHE_DIR=None,
+    ALLOWED_HOSTS=get_test_allowed_hosts(".com"),
+    MULTISITE_EXTRA_HOSTS=[".extrahost.com"],
+)
+class TestCookieDomainMiddleware(TestCase):
+
+    def setUp(self):
+        self.factory = RequestFactory(host="example.com")
+        Site.objects.all().delete()
+        # create sites so we populate ALLOWED_HOSTS
+        Site.objects.create(domain="app.test1.example.com")
+        Site.objects.create(domain="app.test2.example.com")
+        Site.objects.create(domain="example.com")
+        Site.objects.create(domain="new.app.test3.example.com")
+        Site.objects.create(domain="test.example.com")
+
+    def test_init(self):
+        self.assertEqual(CookieDomainMiddleware(HttpResponse).depth, 0)
+        self.assertEqual(
+            CookieDomainMiddleware(HttpResponse).psl_cache_dir, tempfile.gettempdir()
+        )
+
+    @override_settings(
+        MULTISITE_COOKIE_DOMAIN_DEPTH=1, MULTISITE_PUBLIC_SUFFIX_LIST_CACHE_DIR="/var/psl"
+    )
+    def test_init2(self):
+        middleware = CookieDomainMiddleware(HttpResponse)
+        self.assertEqual(middleware.depth, 1)
+        self.assertEqual(middleware.psl_cache_dir, "/var/psl")
+
+    @override_settings(
+        MULTISITE_COOKIE_DOMAIN_DEPTH=-1, MULTISITE_PUBLIC_SUFFIX_LIST_CACHE_DIR=None
+    )
+    def test_init3(self):
+        self.assertRaises(
+            MultisiteCookieDomainDepthError, CookieDomainMiddleware, HttpResponse
+        )
+
+    @override_settings(
+        MULTISITE_COOKIE_DOMAIN_DEPTH="invalid", MULTISITE_PUBLIC_SUFFIX_LIST_CACHE_DIR=None
+    )
+    def test_init4(self):
+        self.assertRaises(
+            MultisiteCookieDomainDepthError, CookieDomainMiddleware, HttpResponse
+        )
+
+    def test_no_matched_cookies(self):
+        # No cookies
+        http_response = get_test_http_response()
+        request = self.factory.get("/")
+        response = CookieDomainMiddleware(http_response)(request)
+        self.assertEqual(response.cookies, SimpleCookie())
+        response = CookieDomainMiddleware(http_response)(request)
+        self.assertEqual(list(response.cookies.values()), [])
+
+        # Add some cookies with their domains already set
+        http_response = get_test_http_response(
+            dict(key="a", value="a", domain=".example.org"),
+            dict(key="b", value="b", domain=".example.co.uk"),
+        )
+        response = CookieDomainMiddleware(http_response)(request)
+        self.assertCountEqual(
+            list(response.cookies.values()), [response.cookies["a"], response.cookies["b"]]
+        )
+        self.assertEqual(response.cookies["a"]["domain"], ".example.org")
+        self.assertEqual(response.cookies["b"]["domain"], ".example.co.uk")
+
+    def test_matched_cookies(self):
+        """Assert no new cookies introduced with multiple responses."""
+        http_response = get_test_http_response(dict(key="a", value="a", domain=None))
+        request = self.factory.get("/")
+        response = CookieDomainMiddleware(http_response)(request)
+        self.assertEqual(list(response.cookies.values()), [response.cookies["a"]])
+        response = CookieDomainMiddleware(http_response)(request)
+        self.assertEqual(list(response.cookies.values()), [response.cookies["a"]])
+
+    @override_settings(ALLOWED_HOSTS=get_test_allowed_hosts("192.0.43.10"))
+    def test_ip_address(self):
+        """Assert IP addresses not be mutated."""
+        http_response = get_test_http_response(dict(key="a", value="a", domain=None))
+        request = self.factory.get("/", host="192.0.43.10")
+        response = CookieDomainMiddleware(http_response)(request)
+        self.assertEqual(response.cookies["a"]["domain"], "")
+
+    @override_settings(
+        ALLOWED_HOSTS=get_test_allowed_hosts("localhost", "localhost.localdomain")
+    )
+    def test_localpath(self):
+        """Assert local domains not mutated."""
+        http_response = get_test_http_response(dict(key="a", value="a", domain=None))
+        request = self.factory.get("/", host="localhost")
+        response = CookieDomainMiddleware(http_response)(request)
+        self.assertEqual(response.cookies["a"]["domain"], "")
+        # Even local subdomains
+        request = self.factory.get("/", host="localhost.localdomain")
+        response = CookieDomainMiddleware(http_response)(request)
+        self.assertEqual(response.cookies["a"]["domain"], "")
+
+    @override_settings(ALLOWED_HOSTS=get_test_allowed_hosts("ai", "www.ai"))
+    def test_simple_tld(self):
+        """Assert top-level domains are not mutated."""
+        http_response = get_test_http_response(dict(key="a", value="a", domain=None))
+        request = self.factory.get("/", host="ai")
+        response = CookieDomainMiddleware(http_response)(request)
+        self.assertEqual(response.cookies["a"]["domain"], "")
+        # Domains inside a TLD are OK
+        request = self.factory.get("/", host="www.ai")
+        response = CookieDomainMiddleware(http_response)(request)
+        self.assertEqual(response.cookies["a"]["domain"], ".www.ai")
+
+    @override_settings(ALLOWED_HOSTS=get_test_allowed_hosts("com.ai", "nic.com.ai"))
+    def test_effective_tld(self):
+        """Assert effective top-level domains with a webserver are
+        not mutated.
+        """
+        http_response = get_test_http_response(dict(key="a", value="a", domain=None))
+        request = self.factory.get("/", host="com.ai")
+        response = CookieDomainMiddleware(http_response)(request)
+        self.assertEqual(response.cookies["a"]["domain"], "")
+        # Domains within an effective TLD are OK
+        request = self.factory.get("/", host="nic.com.ai")
+        response = CookieDomainMiddleware(http_response)(request)
+        self.assertEqual(response.cookies["a"]["domain"], ".nic.com.ai")
+
+    @override_settings(MULTISITE_COOKIE_DOMAIN_DEPTH=1)
+    def test_subdomain_depth(self):
+        """Assert ignores top-level domains but not subdomains."""
+        # At depth 1:
+        http_response = get_test_http_response(dict(key="a", value="a", domain=None))
+        middleware = CookieDomainMiddleware(http_response)
+        # Top-level domains are ignored
+        request = self.factory.get("/", host="com")
+        response = middleware(request)
+        self.assertEqual(response.cookies["a"]["domain"], "")
+        # As are domains within a TLD
+        request = self.factory.get("/", host="example.com")
+        response = middleware(request)
+        self.assertEqual(response.cookies["a"]["domain"], "")
+        # But subdomains will get matched
+        request = self.factory.get("/", host="test.example.com")
+        response = middleware(request)
+        self.assertEqual(response.cookies["a"]["domain"], ".test.example.com")
+        # And sub-subdomains will get matched to 1 level deep
+        response.cookies["a"]["domain"] = ""
+        request = self.factory.get("/", host="app.test1.example.com")
+        response = middleware(request)
+        self.assertEqual(response.cookies["a"]["domain"], ".test1.example.com")
+
+    @override_settings(MULTISITE_COOKIE_DOMAIN_DEPTH=2)
+    def test_subdomain_depth_2(self):
+        """Assert at MULTISITE_COOKIE_DOMAIN_DEPTH 2, subdomains are
+        matched two levels deep.
+        """
+        http_response = get_test_http_response(dict(key="a", value="a", domain=None))
+        middleware = CookieDomainMiddleware(http_response)
+        request = self.factory.get("/", host="app.test2.example.com")
+        response = middleware(request)
+        self.assertEqual(response.cookies["a"]["domain"], ".app.test2.example.com")
+        response.cookies["a"]["domain"] = ""
+        request = self.factory.get("/", host="new.app.test3.example.com")
+        response = middleware(request)
+        self.assertEqual(response.cookies["a"]["domain"], ".app.test3.example.com")
+
+    @override_settings(
+        MULTISITE_COOKIE_DOMAIN_DEPTH=2,
+        ALLOWED_HOSTS=get_test_allowed_hosts(".test.example.com"),
+    )
+    def test_wildcard_subdomains(self):
+        """Assert at MULTISITE_COOKIE_DOMAIN_DEPTH 2, subdomains are
+        matched to two levels deep against the wildcard.
+        """
+        http_response = get_test_http_response(dict(key="a", value="a", domain=None))
+        middleware = CookieDomainMiddleware(http_response)
+        request = self.factory.get("/", host="foo.test.example.com")
+        response = middleware(request)
+        self.assertEqual(response.cookies["a"]["domain"], ".foo.test.example.com")
+        response.cookies["a"]["domain"] = ""
+        request = self.factory.get("/", host="foo.bar.test.example.com")
+        response = middleware(request)
+        self.assertEqual(response.cookies["a"]["domain"], ".bar.test.example.com")