Backwards compatibility of wizard pool

django-cms · czpython · Jul 11, 2018 · Jul 2, 2018 · Jul 2, 2018 · Jul 3, 2018
commit 4a47450f24e622e8c6981392162419d89ba7625d
diff --git a/cms/cms_wizards.py b/cms/cms_wizards.py
@@ -52,6 +52,3 @@ def user_has_add_permission(self, user, page=None, **kwargs):
     model=Page,
     description=_(u"Create a page below the current page.")
 )
-
-wizard_pool.register(cms_page_wizard)
-wizard_pool.register(cms_subpage_wizard)
diff --git a/cms/tests/test_wizards.py b/cms/tests/test_wizards.py
@@ -2,6 +2,7 @@
 from mock import patch, Mock
 
 from django import forms
+from django.apps import apps
 from django.core.urlresolvers import reverse
 from django.core.exceptions import ImproperlyConfigured
 from django.forms.models import ModelForm
@@ -162,28 +163,56 @@ def test_endpoint_auth_required(self):
 
 class TestWizardPool(WizardTestMixin, CMSTestCase):
 
-    def test_discover(self):
-        wizard_pool._reset()
-        self.assertFalse(wizard_pool._discovered)
-        self.assertEqual(len(wizard_pool._entries), 0)
-        wizard_pool._discover()
-        self.assertTrue(wizard_pool._discovered)
-
-    def test_register_unregister_isregistered(self):
-        wizard_pool._clear()
-        self.assertEqual(len(wizard_pool._entries), 0)
-        wizard_pool.register(self.page_wizard)
-        # Now, try to register the same thing
+    def tearDown(self):
+        # Clean up in case anything has been removed or added to the
+        # registered wizards, so other tests don't have problems
+        extension = apps.get_app_config('cms').cms_extension
+        expected_wizards = {
+            cms_page_wizard.id: cms_page_wizard.title,
+            sample_wizard.id: sample_wizard.title,
+            cms_subpage_wizard.id: cms_subpage_wizard.title,
+        }
+        if extension.wizards != expected_wizards:
+            extension.wizards = expected_wizards
+
+    def test_discovered_returns_true(self):
+        # Backwards compatibility
+        self.assertTrue(wizard_pool.discovered)
+
+    def test_is_registered_for_registered_wizard(self):
+        # Backwards compatibility
+        is_registered = wizard_pool.is_registered(cms_page_wizard)
+        self.assertTrue(is_registered)
+
+    def test_is_registered_for_unregistered_wizard(self):
+        # Backwards compatibility
+        is_registered = wizard_pool.is_registered(self.page_wizard)
+        self.assertFalse(is_registered)
+
+    def test_unregister_registered_wizard(self):
+        # Test for backwards compatibility only.
+        was_unregistered = wizard_pool.unregister(cms_page_wizard)
+
+        registered_wizards = apps.get_app_config('cms').cms_extension.wizards
+        self.assertNotIn(cms_page_wizard.id, registered_wizards)
+        self.assertTrue(was_unregistered)
+
+    def test_unregister_unregistered_wizard(self):
+        # Test for backwards compatibility only.
+        was_unregistered = wizard_pool.unregister(self.page_wizard)
+        self.assertFalse(was_unregistered)
+
+    def test_register_already_registered_wizard(self):
+        # Test for backwards compatibility only.
         with self.assertRaises(AlreadyRegisteredException):
-            wizard_pool.register(self.page_wizard)
+            wizard_pool.register(cms_page_wizard)
 
-        self.assertEqual(len(wizard_pool._entries), 1)
-        self.assertTrue(wizard_pool.is_registered(self.page_wizard))
-        self.assertTrue(wizard_pool.unregister(self.page_wizard))
-        self.assertEqual(len(wizard_pool._entries), 0)
+    def test_register_unregistered_wizard(self):
+        # Test for backwards compatibility only.
+        wizard_pool.register(self.page_wizard)
 
-        # Now, try to unregister something that is not registered
-        self.assertFalse(wizard_pool.unregister(self.user_settings_wizard))
+        registered_wizards = apps.get_app_config('cms').cms_extension.wizards
+        self.assertIn(self.page_wiza
8000
rd.id, registered_wizards)
 
     @patch('cms.wizards.wizard_pool.get_entry')
     def test_get_entry(self, mocked_get_entry):

diff --git a/cms/wizards/wizard_pool.py b/cms/wizards/wizard_pool.py
@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*-
+from django.apps import apps
 from django.utils.module_loading import autodiscover_modules
 from django.utils.translation import ugettext as _
 
@@ -21,49 +22,28 @@ def entry_choices(user, page):
 
 
 class WizardPool(object):
-    _entries = {}
-    _discovered = False
-
-    def __init__(self):
-        self._reset()
-
-    # PRIVATE METHODS -----------------
-
-    def _discover(self):
-        if not self._discovered:
-            autodiscover_modules('cms_wizards')
-            self._discovered = True
-
-    def _clear(self):
-        """Simply empties the pool but does not clear the discovered flag."""
-        self._entries = {}
-
-    def _reset(self):
-        """Clears the wizard pool and clears the discovered flag."""
-        self._clear()
-        self._discovered = False
-
-    # PUBLIC METHODS ------------------
 
     @property
     def discovered(self):
         """
-        A public getter for the private property _discovered. Note, there is no
-        public setter.
+        Returns whether all the wizards have been autodiscovered.
+
+        NOTE: This property is for backwards compatibility only
         """
-        return self._discovered
+        # TODO: Add deprecation warning
+        # Always return True because autodiscovering now happens through
+        # the app registration system, so we no longer do any
+        # discovering of registered wizards here
+        return True
 
     def is_registered(self, entry, **kwargs):
         """
         Returns True if the provided entry is registered.
 
-        NOTE: This method triggers pool discovery unless a «passive» kwarg
-        is set to True
+        NOTE: This method is for backwards compatibility only
         """
-        passive = kwargs.get('passive', False)
-        if not passive:
-            self._discover()
-        return entry.id in self._entries
+        # TODO: Add deprecation warning
+        return entry.id in apps.get_app_config('cms').cms_extension.wizards
 
     def register(self, entry):
         """
@@ -80,19 +60,20 @@ def register(self, entry):
                 _(u"A wizard has already been registered for model: %s") %
                 model.__name__)
         else:
-            self._entries[entry.id] = entry
+            apps.get_app_config('cms').cms_extension.wizards[entry.id] = entry
 
     def unregister(self, entry):
         """
         If «entry» is registered into the pool, remove it.
 
         Returns True if the entry was successfully registered, else False.
 
-        NOTE: This method triggers pool discovery.
+        NOTE: This method is here for backwards compatibility only.
         """
+        # TODO: Add deprecation warning
         assert isinstance(entry, Wizard), u"entry must be an instance of Wizard"
-        if self.is_registered(entry, passive=True):
-            del self._entries[entry.id]
+        if self.is_registered(entry):
+            del apps.get_app_config('cms').cms_extension.wizards[entry.id]
             return True
         return False