clone cms with menus, make menus standalone app

cms/tests/test_toolbar_enabled_models.py

@@ -0,0 +1,190 @@
+from unittest.mock import Mock, patch
+
+from django.apps import apps
+from django.contrib.contenttypes.models import ContentType
+from django.core.exceptions import ImproperlyConfigured
+from django.http import Http404
+
+from cms.api import create_page
+from cms.app_registration import get_cms_config_apps, get_cms_extension_apps
+from cms.cms_config import CMSCoreExtensions
+from cms.models import Page, PageContent
+from cms.page_rendering import render_pagecontent
+from cms.test_utils.testcases import CMSTestCase
+from cms.toolbar.toolbar import CMSToolbar
+from cms.utils.setup import setup_cms_apps
+from cms.views import render_object_edit, render_object_preview
+
+
+class ConfigureToolbarEnabledModelsUnitTestCase(CMSTestCase):
+
+    def test_adds_to_mapping(self):
+        """Test that a list of (model, render_func) elements gets
+        correctly added to internal dict with model as a key
+        and render_func as value.
+        """
+        extensions = CMSCoreExtensions()
+        model1 = Mock()
+        model2 = Mock()
+        render_func1 = Mock()
+        render_func2 = Mock()
+        config = [(model1, render_func1), (model2, render_func2)]
+        cms_config = Mock(
+            cms_enabled=True, cms_toolbar_enabled_models=config)
+        extensions.configure_toolbar_enabled_models(cms_config)
+        self.assertDictEqual(
+            extensions.toolbar_enabled_models,
+            {model1: render_func1, model2: render_func2},
+        )
+
+    def test_doesnt_raise_exception_when_toolbar_enabled_models_undefined(self):
+        """
+        If the toolbar enabled models setting is not present in the config, simply
+        ignore this.
+        """
+        extensions = CMSCoreExtensions()
+        cms_config = Mock(cms_enabled=True, spec=[])
+        try:
+            extensions.configure_app(cms_config)
+        except AttributeError:
+            self.fail("Raises exception when cms_toolbar_enabled_models undefined")
+
+    def test_raises_exception_if_not_iterable(self):
+        """
+        If the toolbar enabled models setting isn't iterable, raise an exception.
+        """
+        extensions = CMSCoreExtensions()
+        cms_config = Mock(
+            cms_enabled=True, cms_toolbar_enabled_models=Mock())
+        with self.assertRaises(ImproperlyConfigured):
+            extensions.configure_toolbar_enabled_models(cms_config)
+
+    @patch('cms.cms_config.logger.warning')
+    def test_warning_if_registering_the_same_model_twice(self, mocked_logger):
+        """
+        If a model is already added to the toolbar enabled models dict,
+        log a warning.
+        """
+        extensions = CMSCoreExtensions()
+        model = Mock()
+        render_func = Mock()
+        config = [(model, render_func), (model, render_func)]
+        cms_config = Mock(
+            cms_enabled=True, cms_toolbar_enabled_models=config)
+        extensions.configure_toolbar_enabled_models(cms_config)
+        # Warning message displayed
+        mocked_logger.assert_called_once_with(
+            f"Model {model} already registered for frontend rendering"
+        )
+        # Toolbar enabled models dict is still what we expect it to be
+        self.assertDictEqual(
+            extensions.toolbar_enabled_models,
+            {model: render_func},
+        )
+
+
+class ConfigureToolbarEnabledModelsRenderingIntegrationTestCase(CMSTestCase):
+
+    def setUp(self):
+        # The results of get_cms_extension_apps and get_cms_config_apps
+        # are cached. Clear this cache because installed apps change
+        # between tests and therefore unlike in a live environment,
+        # results of this function can change between tests
+        get_cms_extension_apps.cache_clear()
+        get_cms_config_apps.cache_clear()
+
+    def test_adds_all_toolbar_enabled_models_settings_to_dict(self):
+        """
+        Check that all toolbar enabled models settings are picked up
+        from cms.cms_config.
+        """
+        setup_cms_apps()
+        app = apps.get_app_config('cms')
+        toolbar_enabled_models = app.cms_extension.toolbar_enabled_models
+        self.assertIn(PageContent, toolbar_enabled_models.keys())
+        self.assertEqual(toolbar_enabled_models[PageContent], render_pagecontent)
+
+
+class ToolbarEnabledModelsTestCase(CMSTestCase):
+
+    def test_render_preview_not_supported(self):
+        """Test that attempting to use render_object_preview with
+        unsupported model returns 400 response.
+        """
+        request = self.get_request('/')
+        # The view is called directly here, bypassing the admin_view staff gate,
+        # so give the request an authorized user: the endpoint now runs an
+        # object-level view check before the "supported model" check.
+        request.user = self.get_superuser()
+        request.toolbar = CMSToolbar(request)
+        ctype = ContentType.objects.get_for_model(Page)
+        page = create_page('home', 'nav_playground.html', 'en')
+        response = render_object_preview(request, ctype.pk, page.pk)
+        self.assertEqual(response.status_code, 400)
+
+    def test_render_edit_not_supported(self):
+        """Test that attempting to use render_object_edit with
+        unsupported model returns 400 response.
+        """
+        request = self.get_request('/')
+        request.toolbar = CMSToolbar(request)
+        ctype = ContentType.objects.get_for_model(Page)
+        page = create_page('home', 'nav_playground.html', 'en')
+        response = render_object_edit(request, ctype.pk, page.pk)
+        self.assertEqual(response.status_code, 400)
+
+    def test_render_edit_not_editable_model(self):
+        """Test that attempting to use render_object_edit with
+        a model that doesn't have placeholder field returns 400.
+        """
+        request = self.get_request('/')
+        request.toolbar = CMSToolbar(request)
+        ctype = ContentType.objects.get_for_model(Page)
+        page = create_page('home', 'nav_playground.html', 'en')
+        render_func = Mock()
+        mocked_models = {Page: render_func}
+        extension = apps.get_app_config('cms').cms_extension
+        with patch.object(extension, 'toolbar_enabled_models', mocked_models):
+            response = render_object_edit(request, ctype.pk, page.pk)
+        # even though Page is registered for toolbar enabled models,
+        # it doesn't pass is_editable_model check, so this view returns 400
+        self.assertEqual(response.status_code, 400)
+
+    def test_render_preview_object_not_found(self):
+        """Test that render_object_object returns 404 when provided
+        object id doesn't exist.
+        """
+        request = self.get_request('/')
+        request.toolbar = CMSToolbar(request)
+        ctype = ContentType.objects.get_for_model(Page)
+        page = create_page('home', 'nav_playground.html', 'en')
+        with self.assertRaises(Http404):
+            render_object_preview(request, ctype.pk, page.pk + 100)
+
+    def test_render_preview_ctype_not_found(self):
+        """Test that render_object_object returns 404 when provided
+        content type id doesn't exist.
+        """
+        request = self.get_request('/')
+        request.toolbar = CMSToolbar(request)
+        ctype = ContentType.objects.last()
+        with self.assertRaises(Http404):
+            render_object_preview(request, ctype.pk + 100, 1)
+
+    def test_render_preview_uses_render_func(self):
+        """Test that render_object_preview uses render_func associated
+        with provided model in CMS config.
+        """
+        request = self.get_request('/')
+        # See test_render_preview_not_supported: the direct call needs an
+        # authorized user for the object-level view check.
+        request.user = self.get_superuser()
+        request.toolbar = CMSToolbar(request)
+        ctype = ContentType.objects.get_for_model(Page)
+        page = create_page('home', 'nav_playground.html', 'en')
+        render_func = Mock()
+        mocked_models = {Page: render_func}
+        extension = apps.get_app_config('cms').cms_extension
+        with patch.object(extension, 'toolbar_enabled_models', mocked_models):
+            render_object_preview(request, ctype.pk, page.pk)
+        render_func.assert_called_once_with(request, page)