django-multisite2 2.0.0__py3-none-any.whl

multisite/tests/tests/test_dynamic_site_middleware.py

@@ -0,0 +1,262 @@
+from django.conf import settings
+from django.contrib.sites.models import Site
+from django.core.exceptions import ImproperlyConfigured
+from django.http import Http404, HttpResponse
+from django.test import TestCase, override_settings, tag
+
+from multisite import SiteID
+from multisite.exceptions import MultisiteCacheError, MultisiteError
+from multisite.middleware import DynamicSiteMiddleware
+from multisite.models import Alias
+
+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(
+    ROOT_URLCONF="multisite_app.urls",
+    SITE_ID=SiteID(default=0),
+    CACHE_MULTISITE_ALIAS="multisite",
+    CACHES={
+        "default": {"BACKEND": "django.core.cache.backends.dummy.DummyCache"},
+        "multisite": {"BACKEND": "django.core.cache.backends.dummy.DummyCache"},
+    },
+    MULTISITE_FALLBACK=None,
+    ALLOWED_HOSTS=get_test_allowed_hosts("example.com", "anothersite.example", replace=True),
+)
+class DynamicSiteMiddlewareTest(TestCase):
+    def setUp(self):
+        self.host = "example.com"
+        self.factory = RequestFactory(host=self.host)
+
+        Site.objects.all().delete()
+        self.site = Site.objects.create(pk=1, domain=self.host)
+        self.site2 = Site.objects.create(pk=2, domain="anothersite.example")
+
+    def test_valid_domain(self):
+        # Make the request
+        request = self.factory.get("/")
+        self.assertEqual(DynamicSiteMiddleware(HttpResponse)(request).status_code, 200)
+        self.assertEqual(settings.SITE_ID, self.site.pk)
+        # Request again
+        self.assertEqual(DynamicSiteMiddleware(HttpResponse)(request).status_code, 200)
+        self.assertEqual(settings.SITE_ID, self.site.pk)
+
+    def test_valid_domain_port(self):
+        # Make the request with a specific port
+        request = self.factory.get("/", host=self.host + ":8000")
+        self.assertEqual(DynamicSiteMiddleware(HttpResponse)(request).status_code, 200)
+        self.assertEqual(settings.SITE_ID, self.site.pk)
+        # Request again
+        self.assertEqual(DynamicSiteMiddleware(HttpResponse)(request).status_code, 200)
+        self.assertEqual(settings.SITE_ID, self.site.pk)
+
+    def test_case_sensitivity(self):
+        # Make the request in all uppercase
+        request = self.factory.get("/", host=self.host.upper())
+        self.assertEqual(DynamicSiteMiddleware(HttpResponse)(request).status_code, 200)
+        self.assertEqual(settings.SITE_ID, self.site.pk)
+
+    def test_change_domain(self):
+        # Make the request
+        request = self.factory.get("/")
+        self.assertEqual(DynamicSiteMiddleware(HttpResponse)(request).status_code, 200)
+        self.assertEqual(settings.SITE_ID, self.site.pk)
+        # Another request with a different site
+        request = self.factory.get("/", host=self.site2.domain)
+        self.assertEqual(DynamicSiteMiddleware(HttpResponse)(request).status_code, 200)
+        self.assertEqual(settings.SITE_ID, self.site2.pk)
+
+    def test_unknown_host(self):
+        # Unknown host
+        request = self.factory.get("/", host="unknown")
+        with self.assertRaises(Http404):
+            DynamicSiteMiddleware(HttpResponse)(request)
+        # The middleware resets SiteID to its default value, as given above, on error.
+        self.assertEqual(settings.SITE_ID, 0)
+
+    def test_unknown_hostport(self):
+        # Unknown host:port
+        request = self.factory.get("/", host="unknown:8000")
+        with self.assertRaises(Http404):
+            DynamicSiteMiddleware(HttpResponse)(request)
+        # The middleware resets SiteID to its default value, as given above, on error.
+        self.assertEqual(settings.SITE_ID, 0)
+
+    def test_invalid_host(self):
+        # Invalid host
+        request = self.factory.get("/", host="")
+        with self.assertRaises(Http404):
+            DynamicSiteMiddleware(HttpResponse)(request)
+
+    def test_invalid_hostport(self):
+        # Invalid host:port
+        request = self.factory.get("/", host=":8000")
+        with self.assertRaises(Http404):
+            DynamicSiteMiddleware(HttpResponse)(request)
+
+    def test_no_sites(self):
+        # FIXME: this needs to go into its own TestCase since
+        #  it requires modifying the fixture to work properly
+        # Remove all Sites
+        Site.objects.all().delete()
+        # Make the request
+        request = self.factory.get("/")
+        self.assertRaises(Http404, DynamicSiteMiddleware(HttpResponse), request)
+        # The middleware resets SiteID to its default value, as given above, on error.
+        self.assertEqual(settings.SITE_ID, 0)
+
+    @override_settings(MULTISITE_DEBUG=True)
+    def test_debug_no_sites_raises(self):
+        Site.objects.all().delete()
+        request = self.factory.get("/")
+        self.assertRaises(MultisiteCacheError, DynamicSiteMiddleware(HttpResponse), request)
+
+    @override_settings(MULTISITE_DEBUG=False)
+    def test_no_sites_raises(self):
+        Site.objects.all().delete()
+        request = self.factory.get("/")
+        self.assertRaises(Http404, DynamicSiteMiddleware(HttpResponse), request)
+
+    @override_settings(ALLOWED_HOSTS=["example.org"])
+    def test_redirect(self):
+        host = "example.org"
+        alias = Alias.objects.create(site=self.site, domain=host)
+        self.assertTrue(alias.redirect_to_canonical)
+        # Make the request
+        http_response = get_test_http_response()
+        request = self.factory.get("/path", host=host)
+        response = DynamicSiteMiddleware(http_response)(request)
+        self.assertEqual(response.status_code, 301)
+        self.assertEqual(response["Location"], "http://%s/path" % self.host)
+
+    @override_settings(ALLOWED_HOSTS=["example.org"])
+    def test_no_redirect(self):
+        host = "example.org"
+        Alias.objects.create(site=self.site, domain=host, redirect_to_canonical=False)
+        # Make the request
+        http_response = get_test_http_response()
+        request = self.factory.get("/path", host=host)
+        self.assertEqual(DynamicSiteMiddleware(http_response)(request).status_code, 200)
+        self.assertEqual(settings.SITE_ID, self.site.pk)
+
+    @tag("9")
+    def test_integration(self):
+        """Test that the middleware loads and runs properly
+        under settings.MIDDLEWARE.
+        """
+        self.assertTrue(Site.objects.get(domain="example.com"))
+        self.assertTrue(Site.objects.get(domain="anothersite.example"))
+
+        response = self.client.get("/domain/", HTTP_HOST=self.host)
+        self.assertEqual(response.status_code, 200)
+        self.assertContains(response, self.site.domain)
+        self.assertEqual(settings.SITE_ID, self.site.pk)
+
+        response = self.client.get("/domain/", HTTP_HOST=self.site2.domain)
+        self.assertEqual(response.status_code, 200)
+        self.assertContains(response, self.site2.domain)
+        self.assertEqual(settings.SITE_ID, self.site2.pk)
+
+
+@override_settings(
+    SITE_ID=SiteID(default=0),
+    CACHE_MULTISITE_ALIAS="multisite",
+    CACHES={"multisite": {"BACKEND": "django.core.cache.backends.dummy.DummyCache"}},
+    MULTISITE_FALLBACK=None,
+    MULTISITE_FALLBACK_KWARGS={},
+)
+class DynamicSiteMiddlewareFallbackTest(TestCase):
+    def setUp(self):
+        self.factory = RequestFactory(host="unknown")
+
+        Site.objects.all().delete()
+
+    def test_404(self):
+        http_response = get_test_http_response()
+        request = self.factory.get("/")
+        self.assertRaises(Http404, DynamicSiteMiddleware(http_response), request)
+        self.assertEqual(settings.SITE_ID, 0)
+
+    def test_testserver(self):
+        host = "testserver"
+        site = Site.objects.create(domain=host)
+        http_response = get_test_http_response()
+        request = self.factory.get("/", host=host)
+        self.assertEqual(DynamicSiteMiddleware(http_response)(request).status_code, 200)
+        self.assertEqual(settings.SITE_ID, site.pk)
+
+    def test_string_class(self):
+        # Class based
+        settings.MULTISITE_FALLBACK = "django.views.generic.base.RedirectView"
+        settings.MULTISITE_FALLBACK_KWARGS = {
+            "url": "http://example.com/",
+            "permanent": False,
+        }
+        request = self.factory.get("/")
+        http_response = get_test_http_response()
+        response = DynamicSiteMiddleware(http_response)(request)
+        self.assertEqual(response.status_code, 302)
+        self.assertEqual(response["Location"], settings.MULTISITE_FALLBACK_KWARGS["url"])
+
+    def test_class_view(self):
+        from django.views.generic.base import RedirectView
+
+        settings.MULTISITE_FALLBACK = RedirectView.as_view(
+            url="http://example.com/", permanent=False
+        )
+        http_response = get_test_http_response()
+        request = self.factory.get("/")
+        response = DynamicSiteMiddleware(http_response)(request)
+        self.assertEqual(response.status_code, 302)
+        self.assertEqual(response["Location"], "http://example.com/")
+
+    def test_invalid(self):
+        settings.MULTISITE_FALLBACK = ""
+        http_response = get_test_http_response()
+        request = self.factory.get("/")
+        self.assertRaises(ImproperlyConfigured, DynamicSiteMiddleware(http_response), request)
+
+
+@override_settings(SITE_ID=0)
+class DynamicSiteMiddlewareSettingsTest(TestCase):
+
+    def test_invalid_settings(self):
+        http_response = get_test_http_response()
+        self.assertRaises(MultisiteError, DynamicSiteMiddleware, http_response)
+
+
+@override_settings(
+    SITE_ID=SiteID(default=0),
+    CACHE_MULTISITE_ALIAS="multisite",
+    CACHES={"multisite": {"BACKEND": "django.core.cache.backends.locmem.LocMemCache"}},
+    MULTISITE_FALLBACK=None,
+    ALLOWED_HOSTS=get_test_allowed_hosts("example.com", replace=True),
+)
+class CacheTest(TestCase):
+    def setUp(self):
+        self.host = "example.com"
+        self.factory = RequestFactory(host=self.host)
+
+        Site.objects.all().delete()
+        self.site = Site.objects.create(domain=self.host)
+
+    def test_site_domain_changed(self):
+        # Test to ensure that the cache is cleared properly
+        http_response = get_test_http_response()
+        middleware = DynamicSiteMiddleware(http_response)
+        cache_key = middleware.get_cache_key(self.host)
+        self.assertEqual(middleware.cache.get(cache_key), None)
+        # Make the request
+        request = self.factory.get("/")
+        self.assertEqual(middleware(request).status_code, 200)
+        self.assertEqual(middleware.cache.get(cache_key).site_id, self.site.pk)
+        # Change the domain name
+        self.site.domain = "example.org"
+        self.site.save()
+        self.assertEqual(middleware.cache.get(cache_key), None)
+        # Make the request again, which will now be invalid
+        request = self.factory.get("/")
+        self.assertRaises(Http404, middleware, request)
+        self.assertEqual(settings.SITE_ID, 0)

multisite/tests/tests/test_site_cache.py

@@ -0,0 +1,127 @@
+from django.conf import settings
+from django.contrib.sites.models import Site
+from django.test import TestCase, override_settings
+
+from multisite import SiteID
+from multisite.hacks import use_framework_for_site_cache
+
+
+@override_settings(SITE_ID=SiteID())
+class SiteCacheTest(TestCase):
+    def _initialize_cache(self):
+        # initialize cache again so override key prefix settings are used
+        from django.contrib.sites import models
+
+        use_framework_for_site_cache()
+        self.cache = models.SITE_CACHE
+
+    def setUp(self):
+        from django.contrib.sites import models
+
+        if hasattr(models, "clear_site_cache"):
+            # Before Django 1.6, the Site cache is cleared after the Site
+            # object has been created. This replicates that behaviour.
+            def save(self, *args, **kwargs):
+                super(models.Site, self).save(*args, **kwargs)
+                models.SITE_CACHE.clear()
+
+            models.Site.save = save
+
+        self._initialize_cache()
+        Site.objects.all().delete()
+        self.host = "example.com"
+        self.site = Site.objects.create(domain=self.host)
+        settings.SITE_ID.set(self.site.id)
+
+    def test_get_current(self):
+        self.assertRaises(KeyError, self.cache.__getitem__, self.site.id)
+        # Populate cache
+        self.assertEqual(Site.objects.get_current(), self.site)
+        self.assertEqual(self.cache[self.site.id], self.site)
+        self.assertEqual(self.cache.get(key=self.site.id), self.site)
+        self.assertEqual(self.cache.get(key=-1), None)  # Site doesn't exist
+        self.assertEqual(self.cache.get(-1, "Default"), "Default")  # Site doesn't exist
+        self.assertEqual(
+            self.cache.get(key=-1, default="Non-existant"), "Non-existant"
+        )  # Site doesn't exist
+        self.assertEqual(
+            "Non-existant",
+            self.cache.get(self.site.id, default="Non-existant", version=100),
+        )  # Wrong key version 3
+        # Clear cache
+        self.cache.clear()
+        self.assertRaises(KeyError, self.cache.__getitem__, self.site.id)
+        self.assertEqual(self.cache.get(key=self.site.id, default="Cleared"), "Cleared")
+
+    def test_create_site(self):
+        self.assertEqual(Site.objects.get_current(), self.site)
+        self.assertEqual(Site.objects.get_current().domain, self.site.domain)
+        # Create new site
+        site = Site.objects.create(domain="example.org")
+        settings.SITE_ID.set(site.id)
+        self.assertEqual(Site.objects.get_current(), site)
+        self.assertEqual(Site.objects.get_current().domain, site.domain)
+
+    def test_change_site(self):
+        self.assertEqual(Site.objects.get_current(), self.site)
+        self.assertEqual(Site.objects.get_current().domain, self.site.domain)
+        # Change site domain
+        self.site.domain = "example.org"
+        self.site.save()
+        self.assertEqual(Site.objects.get_current(), self.site)
+        self.assertEqual(Site.objects.get_current().domain, self.site.domain)
+
+    def test_delete_site(self):
+        self.assertEqual(Site.objects.get_current(), self.site)
+        self.assertEqual(Site.objects.get_current().domain, self.site.domain)
+        # Delete site
+        self.site.delete()
+        self.assertRaises(KeyError, self.cache.__getitem__, self.site.id)
+
+    @override_settings(CACHE_MULTISITE_KEY_PREFIX="__test__")
+    def test_multisite_key_prefix(self):
+        self._initialize_cache()
+        # Populate cache
+        self.assertEqual(Site.objects.get_current(), self.site)
+        self.assertEqual(self.cache[self.site.id], self.site)
+        self.assertEqual(
+            self.cache._cache._get_cache_key(self.site.id),
+            "sites.{}.{}".format(settings.CACHE_MULTISITE_KEY_PREFIX, self.site.id),
+            self.cache._cache._get_cache_key(self.site.id),
+        )
+
+    @override_settings(
+        CACHE_MULTISITE_ALIAS="multisite",
+        CACHES={
+            "multisite": {
+                "BACKEND": "django.core.cache.backends.locmem.LocMemCache",
+                "KEY_PREFIX": "looselycoupled",
+            }
+        },
+    )
+    def test_default_key_prefix(self):
+        """
+        If CACHE_MULTISITE_KEY_PREFIX is undefined,
+        the caching system should use CACHES[current]['KEY_PREFIX'].
+        """
+        self._initialize_cache()
+        # Populate cache
+        self.assertEqual(Site.objects.get_current(), self.site)
+        self.assertEqual(self.cache[self.site.id], self.site)
+        self.assertEqual(
+            self.cache._cache._get_cache_key(self.site.id),
+            "sites.looselycoupled.{}".format(self.site.id),
+        )
+
+    @override_settings(
+        CACHE_MULTISITE_KEY_PREFIX="virtuouslyvirtual",
+    )
+    def test_multisite_key_prefix_takes_priority_over_default(self):
+        self._initialize_cache()
+        # Populate cache
+        self.assertEqual(Site.objects.get_current(), self.site)
+        self.assertEqual(self.cache[self.site.id], self.site)
+        self.assertEqual(
+            self.cache._cache._get_cache_key(self.site.id),
+            "sites.virtuouslyvirtual.{}".format(self.site.id),
+        )

multisite/tests/tests/test_site_domain.py

@@ -0,0 +1,24 @@
+from django.contrib.sites.models import Site
+from django.core.exceptions import ObjectDoesNotExist
+from django.test import TestCase
+
+from multisite import SiteDomain
+
+
+class TestSiteDomain(TestCase):
+    def setUp(self):
+        Site.objects.all().delete()
+        self.domain = "example.com"
+        self.site = Site.objects.create(domain=self.domain)
+
+    def test_init(self):
+        self.assertEqual(int(SiteDomain(default=self.domain)), self.site.id)
+        self.assertRaises(ObjectDoesNotExist, int, SiteDomain(default="invalid"))
+        self.assertRaises(TypeError, SiteDomain, default=None)
+        self.assertRaises(TypeError, SiteDomain, default=1)
+
+    def test_deferred_site(self):
+        domain = "example.org"
+        self.assertRaises(ObjectDoesNotExist, int, SiteDomain(default=domain))
+        site = Site.objects.create(domain=domain)
+        self.assertEqual(int(SiteDomain(default=domain)), site.id)

multisite/tests/tests/test_site_id.py

@@ -0,0 +1,76 @@
+from django.contrib.sites.models import Site
+from django.test import TestCase
+
+from multisite import SiteID
+
+
+class TestSiteID(TestCase):
+    def setUp(self):
+        Site.objects.all().delete()
+        self.site = Site.objects.create(domain="example.com")
+        self.site_id = SiteID()
+
+    def test_invalid_default(self):
+        self.assertRaises(ValueError, SiteID, default="a")
+        self.assertRaises(ValueError, SiteID, default=self.site_id)
+
+    def test_compare_default_site_id(self):
+        self.site_id = SiteID(default=self.site.id)
+        self.assertEqual(self.site_id, self.site.id)
+        self.assertFalse(self.site_id != self.site.id)
+        self.assertFalse(self.site_id < self.site.id)
+        self.assertTrue(self.site_id <= self.site.id)
+        self.assertFalse(self.site_id > self.site.id)
+        self.assertTrue(self.site_id >= self.site.id)
+
+    def test_compare_site_ids(self):
+        self.site_id.set(1)
+        self.assertEqual(self.site_id, self.site_id)
+        self.assertFalse(self.site_id != self.site_id)
+        self.assertFalse(self.site_id < self.site_id)
+        self.assertTrue(self.site_id <= self.site_id)
+        self.assertFalse(self.site_id > self.site_id)
+        self.assertTrue(self.site_id >= self.site_id)
+
+    def test_compare_differing_types(self):
+        self.site_id.set(1)
+        self.assertNotEqual(self.site_id, "1")
+        self.assertFalse(self.site_id == "1")
+        self.assertTrue(self.site_id < "1")
+        self.assertTrue(self.site_id <= "1")
+        self.assertFalse(self.site_id > "1")
+        self.assertFalse(self.site_id >= "1")
+        self.assertNotEqual("1", self.site_id)
+        self.assertFalse("1" == self.site_id)
+        self.assertFalse("1" < self.site_id)
+        self.assertFalse("1" <= self.site_id)
+        self.assertTrue("1" > self.site_id)
+        self.assertTrue("1" >= self.site_id)
+
+    def test_set(self):
+        self.site_id.set(10)
+        self.assertEqual(int(self.site_id), 10)
+        self.site_id.set(20)
+        self.assertEqual(int(self.site_id), 20)
+        self.site_id.set(self.site)
+        self.assertEqual(int(self.site_id), self.site.id)
+
+    def test_hash(self):
+        self.site_id.set(10)
+        self.assertEqual(hash(self.site_id), 10)
+        self.site_id.set(20)
+        self.assertEqual(hash(self.site_id), 20)
+
+    def test_str_repr(self):
+        self.site_id.set(10)
+        self.assertEqual(str(self.site_id), "10")
+        self.assertEqual(repr(self.site_id), "10")
+
+    def test_context_manager(self):
+        self.assertEqual(self.site_id.site_id, None)
+        with self.site_id.override(1):
+            self.assertEqual(self.site_id.site_id, 1)
+            with self.site_id.override(2):
+                self.assertEqual(self.site_id.site_id, 2)
+            self.assertEqual(self.site_id.site_id, 1)
+        self.assertEqual(self.site_id.site_id, None)

multisite/tests/tests/test_template_loader.py

@@ -0,0 +1,49 @@
+import logging
+import os
+import tempfile
+from io import StringIO
+from pathlib import Path
+from unittest import mock
+
+from django.core.management import call_command
+from django.template.loader import get_template
+from django.test import TestCase, override_settings, tag
+
+
+class UpdatePublicSuffixListCommandTestCase(TestCase):
+    def setUp(self):
+        self.cache_dir = tempfile.gettempdir()
+        # save the tldextract logger output to a buffer to test output
+        self.out = StringIO()
+        self.logger = logging.getLogger("tldextract")
+        self.logger.setLevel(logging.DEBUG)
+        stdout_handler = logging.StreamHandler(self.out)
+        stdout_handler.setLevel(logging.DEBUG)
+        self.logger.addHandler(stdout_handler)
+
+        # patch tldextract to avoid actual requests
+        self.patcher = mock.patch("tldextract.TLDExtract")
+        self.tldextract = self.patcher.start()
+
+    def tearDown(self):
+        self.patcher.stop()
+
+    def tldextract_update_side_effect(self, *args, **kwargs):
+        self.logger.debug("TLDExtract.update called")
+
+    def test_command(self):
+        call_command("update_public_suffix_list")
+        expected_calls = [
+            mock.call(cache_dir=self.cache_dir),
+            mock.call().update(fetch_now=True),
+        ]
+        self.assertEqual(self.tldextract.mock_calls, expected_calls)
+
+    def test_command_output(self):
+        # make sure that the logger receives output from the method
+        self.tldextract().update.side_effect = self.tldextract_update_side_effect
+
+        call_command("update_public_suffix_list", verbosity=3)
+        update_message = "Updating {}".format(self.cache_dir)
+        self.assertIn(update_message, self.out.getvalue())
+        self.assertIn("TLDExtract.update called", self.out.getvalue())

multisite/threadlocals.py

@@ -0,0 +1,136 @@
+from contextlib import contextmanager
+from threading import local
+
+from django.conf import settings
+from django.core.exceptions import ImproperlyConfigured
+
+
+class SiteID(local):
+    """
+    Dynamic settings.SITE_ID replacement, which acts like an integer.
+
+    django.contrib.sites can allow multiple Django sites to share the
+    same database. However, they cannot share the same code by
+    default.
+
+    SiteID can be used to replace the static settings.SITE_ID integer
+    when combined with the appropriate middleware.
+    """
+
+    def __init__(self, default=None, *args, **kwargs):
+        """
+        ``default``, if specified, determines the default SITE_ID,
+        if that is unset.
+        """
+        if default is not None and not isinstance(default, int):
+            raise ValueError("%r is not a valid default." % default)
+        self.default = default
+        self.reset()
+
+    def __repr__(self):
+        return repr(self.__int__())
+
+    def __str__(self):
+        return str(self.__int__())
+
+    def __int__(self):
+        if self.site_id is None:
+            return self.get_default()
+        return self.site_id
+
+    def __lt__(self, other):
+        if isinstance(other, int):
+            return self.__int__() < other
+        elif isinstance(other, SiteID):
+            return self.__int__() < other.__int__()
+        return True
+
+    def __le__(self, other):
+        if isinstance(other, int):
+            return self.__int__() <= other
+        elif isinstance(other, SiteID):
+            return self.__int__() <= other.__int__()
+        return True
+
+    def __eq__(self, other):
+        if isinstance(other, int):
+            return self.__int__() == other
+        elif isinstance(other, SiteID):
+            return self.__int__() == other.__int__()
+        return False
+
+    def __ne__(self, other):
+        return not self.__eq__(other)
+
+    def __gt__(self, other):
+        return not self.__le__(other)
+
+    def __ge__(self, other):
+        return not self.__lt__(other)
+
+    def __hash__(self):
+        return self.__int__()
+
+    @contextmanager
+    def override(self, value):
+        """
+        Overrides SITE_ID temporarily::
+
+           >>> with settings.SITE_ID.override(2):
+           ...    print settings.SITE_ID
+           2
+        """
+        site_id_original = self.site_id
+        self.set(value)
+        try:
+            yield self
+        finally:
+            self.site_id = site_id_original
+
+    def set(self, value):
+        from django.db.models import Model
+
+        if isinstance(value, Model):
+            value = value.pk
+        self.site_id = value
+
+    def reset(self):
+        self.site_id = None
+
+    def get_default(self):
+        """Returns the default SITE_ID."""
+        if self.default is None:
+            raise ValueError("SITE_ID has not been set.")
+        return self.default
+
+
+class SiteDomain(SiteID):
+    def __init__(self, default, *args, **kwargs):
+        """
+        ``default`` is the default domain name, resolved to SITE_ID, if
+        that is unset.
+        """
+        # make sure they passed us a string; doing this is the single
+        # hardest py2/py3 compat headache.
+        # http://python-future.org/compatible_idioms.html#basestring and
+        # https://github.com/PythonCharmers/python-future/blob/master/src/past/types/basestring.py
+        # are not super informative, so just fall back on a literal version check:
+        if not isinstance(default, str):
+            raise TypeError("%r is not a valid default domain." % default)
+        self.default_domain = default
+        self.default = None
+        self.reset()
+
+    def get_default(self):
+        """Returns the default SITE_ID that matches the default domain name."""
+        from django.contrib.sites.models import Site
+
+        if "django.contrib.sites" not in settings.INSTALLED_APPS:
+            raise ImproperlyConfigured(
+                "django.contrib.sites is not in settings.INSTALLED_APPS"
+            )
+
+        if self.default is None:
+            qset = Site.objects.only("id")
+            self.default = qset.get(domain=self.default_domain).id
+        return self.default