Merge 9d110fd into 0ac87d3

changes/167.feature

@@ -0,0 +1 @@
+Refactor settings to make override_settings in tests more consistent

meta/models.py

@@ -1,9 +1,7 @@
 import warnings
 from copy import copy
 
-from django.conf import settings as dj_settings
-
-from . import settings
+from .settings import get_setting
 from .utils import get_request, set_request
 
 NEED_REQUEST_OBJECT_ERR_MSG = (
@@ -28,28 +26,28 @@ class ModelMeta:
         "twitter_description": False,
         "schemaorg_description": False,
         "keywords": False,
-        "image": settings.DEFAULT_IMAGE,
+        "image": get_setting("DEFAULT_IMAGE"),
         "image_object": None,
         "image_width": False,
         "image_height": False,
-        "object_type": settings.DEFAULT_TYPE,
-        "og_type": settings.FB_TYPE,
-        "og_app_id": settings.FB_APPID,
-        "og_profile_id": settings.FB_PROFILE_ID,
-        "og_publisher": settings.FB_PUBLISHER,
-        "og_author_url": settings.FB_AUTHOR_URL,
-        "fb_pages": settings.FB_PAGES,
-        "twitter_type": settings.TWITTER_TYPE,
-        "twitter_site": settings.TWITTER_SITE,
-        "twitter_author": settings.TWITTER_AUTHOR,
-        "schemaorg_type": settings.SCHEMAORG_TYPE,
+        "object_type": get_setting("DEFAULT_TYPE"),
+        "og_type": get_setting("FB_TYPE"),
+        "og_app_id": get_setting("FB_APPID"),
+        "og_profile_id": get_setting("FB_PROFILE_ID"),
+        "og_publisher": get_setting("FB_PUBLISHER"),
+        "og_author_url": get_setting("FB_AUTHOR_URL"),
+        "fb_pages": get_setting("FB_PAGES"),
+        "twitter_type": get_setting("TWITTER_TYPE"),
+        "twitter_site": get_setting("TWITTER_SITE"),
+        "twitter_author": get_setting("TWITTER_AUTHOR"),
+        "schemaorg_type": get_setting("SCHEMAORG_TYPE"),
         "published_time": False,
         "modified_time": False,
         "expiration_time": False,
         "tag": False,
         "url": False,
         "locale": False,
-        "custom_namespace": settings.OG_NAMESPACES,
+        "custom_namespace": get_setting("OG_NAMESPACES"),
     }
 
     def get_meta(self, request=None):
@@ -178,7 +176,7 @@ def get_meta_protocol(self):
         """
         Current http protocol
         """
-        return dj_settings.META_SITE_PROTOCOL
+        return get_setting("SITE_PROTOCOL")
 
     def build_absolute_uri(self, url):
         """
@@ -188,7 +186,7 @@ def build_absolute_uri(self, url):
         if request:
             return request.build_absolute_uri(url)
 
-        if not settings.USE_SITES:
+        if not get_setting("USE_SITES"):
             raise RuntimeError(NEED_REQUEST_OBJECT_ERR_MSG)
 
         from django.contrib.sites.models import Site

meta/settings.py

@@ -1,20 +1,20 @@
 from django.conf import settings as django_settings
 from django.utils.translation import gettext_lazy as _
 
-SITE_PROTOCOL = getattr(django_settings, "META_SITE_PROTOCOL", None)
-SITE_DOMAIN = getattr(django_settings, "META_SITE_DOMAIN", None)
-SITE_TYPE = getattr(django_settings, "META_SITE_TYPE", None)
-SITE_NAME = getattr(django_settings, "META_SITE_NAME", None)
-INCLUDE_KEYWORDS = getattr(django_settings, "META_INCLUDE_KEYWORDS", [])
-DEFAULT_KEYWORDS = getattr(django_settings, "META_DEFAULT_KEYWORDS", [])
-IMAGE_URL = getattr(django_settings, "META_IMAGE_URL", django_settings.STATIC_URL)
-USE_OG_PROPERTIES = getattr(django_settings, "META_USE_OG_PROPERTIES", False)
-USE_TWITTER_PROPERTIES = getattr(django_settings, "META_USE_TWITTER_PROPERTIES", False)
-USE_FACEBOOK_PROPERTIES = getattr(django_settings, "META_USE_FACEBOOK_PROPERTIES", False)
-USE_SCHEMAORG_PROPERTIES = getattr(django_settings, "META_USE_SCHEMAORG_PROPERTIES", False)
-USE_SITES = getattr(django_settings, "META_USE_SITES", False)
-USE_TITLE_TAG = getattr(django_settings, "META_USE_TITLE_TAG", False)
-OG_NAMESPACES = getattr(django_settings, "META_OG_NAMESPACES", None)
+META_SITE_PROTOCOL = None
+META_SITE_DOMAIN = None
+META_SITE_TYPE = None
+META_SITE_NAME = None
+META_INCLUDE_KEYWORDS = []
+META_DEFAULT_KEYWORDS = []
+META_IMAGE_URL = django_settings.STATIC_URL
+META_USE_OG_PROPERTIES = False
+META_USE_TWITTER_PROPERTIES = False
+META_USE_FACEBOOK_PROPERTIES = False
+META_USE_SCHEMAORG_PROPERTIES = False
+META_USE_SITES = False
+META_USE_TITLE_TAG = False
+META_OG_NAMESPACES = None
 
 OBJECT_TYPES = (
     ("Article", _("Article")),
@@ -44,19 +44,28 @@
     ("Review", _("Review")),
 )
 
-OG_SECURE_URL_ITEMS = getattr(django_settings, "META_OG_SECURE_URL_ITEMS", ("image", "audio", "video"))
-DEFAULT_IMAGE = getattr(django_settings, "META_DEFAULT_IMAGE", "")
-DEFAULT_TYPE = getattr(django_settings, "META_SITE_TYPE", OBJECT_TYPES[0][0])
-FB_TYPE = getattr(django_settings, "META_FB_TYPE", OBJECT_TYPES[0][0])
-FB_TYPES = getattr(django_settings, "META_FB_TYPES", FB_TYPES)
-FB_APPID = getattr(django_settings, "META_FB_APPID", "")
-FB_PROFILE_ID = getattr(django_settings, "META_FB_PROFILE_ID", "")
-FB_PUBLISHER = getattr(django_settings, "META_FB_PUBLISHER", "")
-FB_AUTHOR_URL = getattr(django_settings, "META_FB_AUTHOR_URL", "")
-FB_PAGES = getattr(django_settings, "META_FB_PAGES", "")
-TWITTER_TYPE = getattr(django_settings, "META_TWITTER_TYPE", TWITTER_TYPES[0][0])
-TWITTER_TYPES = getattr(django_settings, "META_TWITTER_TYPES", TWITTER_TYPES)
-TWITTER_SITE = getattr(django_settings, "META_TWITTER_SITE", "")
-TWITTER_AUTHOR = getattr(django_settings, "META_TWITTER_AUTHOR", "")
-SCHEMAORG_TYPE = getattr(django_settings, "META_SCHEMAORG_TYPE", SCHEMAORG_TYPES[0][0])
-SCHEMAORG_TYPES = getattr(django_settings, "META_SCHEMAORG_TYPES", SCHEMAORG_TYPES)
+META_OG_SECURE_URL_ITEMS = ("image", "audio", "video")
+META_DEFAULT_IMAGE = ""
+META_DEFAULT_TYPE = OBJECT_TYPES[0][0]
+META_FB_TYPE = OBJECT_TYPES[0][0]
+META_FB_TYPES = FB_TYPES
+META_FB_APPID = ""
+META_FB_PROFILE_ID = ""
+META_FB_PUBLISHER = ""
+META_FB_AUTHOR_URL = ""
+META_FB_PAGES = ""
+META_TWITTER_TYPE = TWITTER_TYPES[0][0]
+META_TWITTER_TYPES = TWITTER_TYPES
+META_TWITTER_SITE = ""
+META_TWITTER_AUTHOR = ""
+META_SCHEMAORG_TYPE = SCHEMAORG_TYPES[0][0]
+META_SCHEMAORG_TYPES = SCHEMAORG_TYPES
+
+params = {param: value for param, value in locals().items() if param.startswith("META_")}
+
+
+def get_setting(name):
+    """Get setting value from django settings with fallback to globals defaults."""
+    from django.conf import settings
+
+    return getattr(settings, "META_%s" % name, params["META_%s" % name])

meta/templatetags/meta.py

@@ -6,7 +6,7 @@
 from django.utils.html import escape
 from django.utils.safestring import mark_safe
 
-from .. import settings
+from ..settings import get_setting
 
 register = template.Library()
 
@@ -124,7 +124,7 @@ def og_prop(name, value):
     :param name: property name (without 'og:' namespace)
     :param value: property value
     """
-    if not isinstance(value, dict) and name in settings.OG_SECURE_URL_ITEMS and value.startswith("https"):
+    if not isinstance(value, dict) and name in get_setting("OG_SECURE_URL_ITEMS") and value.startswith("https"):
         data = {name: value, "%s:secure_url" % name: value}
     elif not isinstance(value, dict):
         data = {

meta/views.py

@@ -2,7 +2,7 @@
 
 from django.core.exceptions import ImproperlyConfigured
 
-from . import settings
+from .settings import get_setting
 
 
 class Meta:
@@ -18,7 +18,7 @@ class Meta:
 
     def __init__(self, **kwargs):
         self.request = kwargs.get("request", None)
-        self.use_sites = kwargs.get("use_sites", settings.USE_SITES)
+        self.use_sites = kwargs.get("use_sites", get_setting("USE_SITES"))
         self.title = kwargs.get("title")
         self.og_title = kwargs.get("og_title")
         self.twitter_title = kwargs.get("twitter_title")
@@ -27,43 +27,43 @@ def __init__(self, **kwargs):
         self.description = kwargs.get("description")
         self.extra_props = kwargs.get("extra_props")
         self.extra_custom_props = kwargs.get("extra_custom_props")
-        self.custom_namespace = kwargs.get("custom_namespace", settings.OG_NAMESPACES)
+        self.custom_namespace = kwargs.get("custom_namespace", get_setting("OG_NAMESPACES"))
         self.keywords = kwargs.get("keywords")
         self.url = kwargs.get("url")
         self.image = kwargs.get("image")
         self.image_object = kwargs.get("image_object")
         self.image_width = kwargs.get("image_width")
         self.image_height = kwargs.get("image_height")
-        self.object_type = kwargs.get("object_type", settings.SITE_TYPE)
-        self.site_name = kwargs.get("site_name", settings.SITE_NAME)
+        self.object_type = kwargs.get("object_type", get_setting("SITE_TYPE"))
+        self.site_name = kwargs.get("site_name", get_setting("SITE_NAME"))
         self.twitter_site = kwargs.get("twitter_site")
         self.twitter_creator = kwargs.get("twitter_creator")
-        self.twitter_type = kwargs.get("twitter_type", kwargs.get("twitter_card", settings.TWITTER_TYPE))
+        self.twitter_type = kwargs.get("twitter_type", kwargs.get("twitter_card", get_setting("TWITTER_TYPE")))
         self.twitter_card = self.twitter_type
         self.facebook_app_id = kwargs.get("facebook_app_id")
         self.locale = kwargs.get("locale")
-        self.use_og = kwargs.get("use_og", settings.USE_OG_PROPERTIES)
-        self.use_twitter = kwargs.get("use_twitter", settings.USE_TWITTER_PROPERTIES)
-        self.use_facebook = kwargs.get("use_facebook", settings.USE_FACEBOOK_PROPERTIES)
-        self.use_schemaorg = kwargs.get("use_schemaorg", settings.USE_SCHEMAORG_PROPERTIES)
-        self.use_title_tag = kwargs.get("use_title_tag", settings.USE_TITLE_TAG)
-        self.schemaorg_type = kwargs.get("schemaorg_type", settings.SCHEMAORG_TYPE)
-        self.fb_pages = kwargs.get("fb_pages", settings.FB_PAGES)
-        self.og_app_id = kwargs.get("og_app_id", settings.FB_APPID)
+        self.use_og = kwargs.get("use_og", get_setting("USE_OG_PROPERTIES"))
+        self.use_twitter = kwargs.get("use_twitter", get_setting("USE_TWITTER_PROPERTIES"))
+        self.use_facebook = kwargs.get("use_facebook", get_setting("USE_FACEBOOK_PROPERTIES"))
+        self.use_schemaorg = kwargs.get("use_schemaorg", get_setting("USE_SCHEMAORG_PROPERTIES"))
+        self.use_title_tag = kwargs.get("use_title_tag", get_setting("USE_TITLE_TAG"))
+        self.schemaorg_type = kwargs.get("schemaorg_type", get_setting("SCHEMAORG_TYPE"))
+        self.fb_pages = kwargs.get("fb_pages", get_setting("FB_PAGES"))
+        self.og_app_id = kwargs.get("og_app_id", get_setting("FB_APPID"))
 
     def get_domain(self):
         if self.use_sites:
             from django.contrib.sites.models import Site
 
             return Site.objects.get_current(self.request).domain
-        if not settings.SITE_DOMAIN:
+        if not get_setting("SITE_DOMAIN"):
             raise ImproperlyConfigured("META_SITE_DOMAIN is not set")
-        return settings.SITE_DOMAIN
+        return get_setting("SITE_DOMAIN")
 
     def get_protocol(self):
-        if not settings.SITE_PROTOCOL:
+        if not get_setting("SITE_PROTOCOL"):
             raise ImproperlyConfigured("META_SITE_PROTOCOL is not set")
-        return settings.SITE_PROTOCOL
+        return get_setting("SITE_PROTOCOL")
 
     def get_full_url(self, url):
         if not url:
@@ -83,14 +83,14 @@ def keywords(self):
     @keywords.setter
     def keywords(self, keywords):
         if keywords is None:
-            kws = settings.DEFAULT_KEYWORDS
+            kws = get_setting("DEFAULT_KEYWORDS")
         else:
             if not hasattr(keywords, "__iter__"):
                 # Not iterable
                 raise ValueError("Keywords must be an intrable")
             kws = list(keywords)
-            if settings.INCLUDE_KEYWORDS:
-                kws += settings.INCLUDE_KEYWORDS
+            if get_setting("INCLUDE_KEYWORDS"):
+                kws += get_setting("INCLUDE_KEYWORDS")
         seen = set()
         seen_add = seen.add
         self._keywords = [k for k in kws if k not in seen and not seen_add(k)]
@@ -105,7 +105,7 @@ def url(self, url):
 
     def _normalize_media_url(self, url):
         if not url.startswith("http") and not url.startswith("/"):
-            url = "{}{}".format(settings.IMAGE_URL, url)
+            url = "{}{}".format(get_setting("IMAGE_URL"), url)
         return self.get_full_url(url)
 
     @property
@@ -117,8 +117,8 @@ def image(self):
 
     @image.setter
     def image(self, image):
-        if image is None and settings.DEFAULT_IMAGE:
-            image = settings.DEFAULT_IMAGE
+        if image is None and get_setting("DEFAULT_IMAGE"):
+            image = get_setting("DEFAULT_IMAGE")
         if image:
             self._image = self._normalize_media_url(image)
 
@@ -175,19 +175,19 @@ class MetadataMixin:
     schemaorg_type = None
 
     def __init__(self, **kwargs):
-        self.use_sites = settings.USE_SITES
-        self.use_og = settings.USE_OG_PROPERTIES
-        self.use_title_tag = settings.USE_TITLE_TAG
+        self.use_sites = get_setting("USE_SITES")
+        self.use_og = get_setting("USE_OG_PROPERTIES")
+        self.use_title_tag = get_setting("USE_TITLE_TAG")
         super().__init__(**kwargs)
 
     def get_meta_class(self):
         return self.meta_class
 
     def get_protocol(self):
-        return settings.SITE_PROTOCOL
+        return get_setting("SITE_PROTOCOL")
 
     def get_domain(self):
-        return settings.SITE_DOMAIN
+        return get_setting("SITE_DOMAIN")
 
     def get_meta_title(self, context=None):
         return self.title
@@ -222,10 +222,10 @@ def get_meta_image_object(self, context=None):
         return self.image_object
 
     def get_meta_object_type(self, context=None):
-        return self.object_type or settings.SITE_TYPE
+        return self.object_type or get_setting("SITE_TYPE")
 
     def get_meta_site_name(self, context=None):
-        return self.site_name or settings.SITE_NAME
+        return self.site_name or get_setting("SITE_NAME")
 
     def get_meta_extra_props(self, context=None):
         return self.extra_props
@@ -234,7 +234,7 @@ def get_meta_extra_custom_props(self, context=None):
         return self.extra_custom_props
 
     def get_meta_custom_namespace(self, context=None):
-        return self.custom_namespace or settings.OG_NAMESPACES
+        return self.custom_namespace or get_setting("OG_NAMESPACES")
 
     def get_meta_twitter_site(self, context=None):
         return self.twitter_site

tests/test_asgi.py

@@ -9,7 +9,7 @@
 
 try:
     from asgiref.sync import sync_to_async
-    from django.test import AsyncRequestFactory
+    from django.test import AsyncRequestFactory, override_settings
 except ImportError:
     # stub to avoid decorator failures
     def sync_to_async(__):
@@ -35,7 +35,6 @@ def get_post(title):
         text="post text",
         image_url="/path/to/image",
     )
-    print(post.og_title)
     return post
 
 
@@ -53,18 +52,20 @@ def get_meta(post, request=None):
 @pytest.mark.asyncio
 @pytest.mark.django_db
 async def test_mixin_on_asgi():
-    post = await get_post("first post")
-    meta = await get_meta(post)
-    assert meta.title == "first post"
-    assert meta.og_title == "og first post"
+    with override_settings(META_USE_SITES=True, META_SITE_PROTOCOL="http", META_USE_OG_PROPERTIES=True):
+        post = await get_post("first post")
+        meta = await get_meta(post)
+        assert meta.title == "first post"
+        assert meta.og_title == "og first post"
 
 
 @minversion
 @pytest.mark.asyncio
 @pytest.mark.django_db
 async def test_mixin_on_asgi_request():
-    request = AsyncRequestFactory().get("/")
-    post = await get_post("first post")
-    meta = await get_meta(post, request)
-    assert meta.title == "first post"
-    assert meta.og_title == "og first post"
+    with override_settings(META_USE_SITES=True, META_SITE_PROTOCOL="http", META_USE_OG_PROPERTIES=True):
+        request = AsyncRequestFactory().get("/")
+        post = await get_post("first post")
+        meta = await get_meta(post, request)
+        assert meta.title == "first post"
+        assert meta.og_title == "og first post"