Fix unit test.

see #951

modoboa/core/tests/test_core.py

@@ -7,6 +7,7 @@ import httmock
 from django.core import management
 from django.core.urlresolvers import reverse
 from django.test import override_settings, TestCase
+from django.utils.functional import cached_property
 
 from modoboa.lib import exceptions
 from modoboa.lib.tests import ModoTestCase
@@ -61,6 +62,12 @@ class ChangeDefaultAdminTestCase(TestCase):
 class LDAPTestCaseMixin(object):
     """Set of methods used to test LDAP features."""
 
+    @cached_property
+    def ldapauthbackend(self):
+        """Return LDAPAuthBackend instance."""
+        from modoboa.lib.ldap_utils import LDAPAuthBackend
+        return LDAPAuthBackend()
+
     def activate_ldap_authentication(self):
         """Modify settings."""
         self.set_global_parameters({
@@ -70,12 +77,9 @@ class LDAPTestCaseMixin(object):
 
     def restore_user_password(self, username, new_password):
         """Restore user password to its initial state."""
-        from modoboa.lib.ldap_utils import LDAPAuthBackend
-
-        backend = LDAPAuthBackend()
         for password in ["Toto1234", "test"]:
             try:
-                backend.update_user_password(
+                self.ldapauthbackend.update_user_password(
                     username, password, new_password)
             except exceptions.InternalError:
                 pass
@@ -136,7 +140,6 @@ class LDAPAuthenticationTestCase(LDAPTestCaseMixin, ModoTestCase):
         username = "testuser@example.com"
         self.authenticate(username, "test")
         self.check_created_user(username)
-        self.client.logout()
 
         self.set_global_parameters({
             "ldap_admin_groups": "admins",

modoboa/lib/authbackends.py

@@ -37,6 +37,8 @@ try:
             """Load LDAP settings."""
             param_tools.apply_to_django_settings()
             super(LDAPBackend, self).__init__(*args, **kwargs)
+            self.global_params = dict(
+                param_tools.get_global_parameters("core"))
 
         def get_or_create_user(self, username, ldap_user):
             """
@@ -45,13 +47,11 @@ try:
             the user. ldap_user.dn is the user's DN and
             ldap_user.attrs contains all of their LDAP attributes.
             """
-            group = 'SimpleUsers'
-            admin_groups = (
-                param_tools.get_global_parameter(
-                    "ldap_admin_groups", app="core").split(";"))
+            group = "SimpleUsers"
+            admin_groups = self.global_params["ldap_admin_groups"].split(";")
             for grp in admin_groups:
                 if grp.strip() in ldap_user.group_names:
-                    group = 'DomainAdmins'
+                    group = "DomainAdmins"
                     break
             if group == 'SimpleUsers':
                 lpart, domain = split_mailbox(username)
@@ -75,9 +75,7 @@ try:
             return user
 
         def authenticate(self, username, password):
-            auth_type = param_tools.get_global_parameter(
-                "authentication_type", app="core")
-            if auth_type == "ldap":
+            if self.global_params["authentication_type"] == "ldap":
                 return super(LDAPBackend, self).authenticate(
                     username, password)
             return None

modoboa/lib/ldap_utils.py

@@ -47,6 +47,7 @@ class LDAPAuthBackend(object):
 
     def __init__(self):
         param_tools.apply_to_django_settings()
+        self.global_params = dict(param_tools.get_global_parameters("core"))
         self.server_uri = self._setting(
             "AUTH_LDAP_SERVER_URI", "ldap://localhost"
         )
@@ -74,7 +75,7 @@ class LDAPAuthBackend(object):
         """Connect to the server according to configuration."""
         if self.conn is not None:
             return
-        mode = param_tools.get_global_parameter("ldap_auth_method", app="core")
+        mode = self.global_params["ldap_auth_method"]
         if mode == "searchbind":
             bind_dn = self._setting("AUTH_LDAP_BIND_DN", "")
             bind_pwd = self._setting("AUTH_LDAP_BIND_PASSWORD", "")
@@ -86,9 +87,8 @@ class LDAPAuthBackend(object):
 
     def _find_user_dn(self, user):
         """Find the DN of the given user."""
-        core_params = dict(param_tools.get_global_parameters("core"))
-        sbase = core_params["ldap_search_base"]
-        sfilter = core_params["ldap_search_filter"]
+        sbase = self.global_params["ldap_search_base"]
+        sfilter = self.global_params["ldap_search_filter"]
         sfilter = sfilter % {"user": user}
         res = self.conn.search_s(sbase, ldap.SCOPE_SUBTREE, sfilter)
         try:
@@ -103,9 +103,8 @@ class LDAPAuthBackend(object):
         :param clearpassword: the clear password
         :return: the encrypted password
         """
-        scheme = param_tools.get_global_parameter(
-            "password_scheme", app="core")
-        hasher = get_password_hasher(scheme.upper())('ldap')
+        scheme = self.global_params["password_scheme"]
+        hasher = get_password_hasher(scheme.upper())("ldap")
         return hasher.encrypt(clearpassword)
 
     def update_user_password(self, user, password, newpassword):

modoboa/limits/handlers.py

@@ -44,15 +44,14 @@ def create_user_limits(sender, instance, **kwargs):
         return
     request = lib_signals.get_request()
     creator = request.user if request else None
+    global_params = dict(param_tools.get_global_parameters("limits"))
     for name, definition in utils.get_user_limit_templates():
         ct = ContentType.objects.get_by_natural_key(
             *definition["content_type"].split("."))
         max_value = 0
         # creator can be None if user was created by a factory
         if not creator or creator.is_superuser:
-            max_value = (
-                param_tools.get_global_parameter(
-                    "deflt_user_{0}_limit".format(name)))
+            max_value = global_params["deflt_user_{0}_limit".format(name)]
         models.UserObjectLimit.objects.create(
             user=instance, name=name, content_type=ct, max_value=max_value)
 
@@ -62,10 +61,9 @@ def create_domain_limits(sender, instance, **kwargs):
     """Create limits for new domain."""
     if not kwargs.get("created"):
         return
+    global_params = dict(param_tools.get_global_parameters("limits"))
     for name, definition in utils.get_domain_limit_templates():
-        max_value = (
-            param_tools.get_global_parameter(
-                "deflt_domain_{0}_limit".format(name)))
+        max_value = global_params["deflt_domain_{0}_limit".format(name)]
         models.DomainObjectLimit.objects.create(
             domain=instance, name=name, max_value=max_value)
 

modoboa/parameters/tools.py

@@ -1,5 +1,7 @@
 """Parameters management."""
 
+import copy
+
 from modoboa.lib import exceptions
 from modoboa.lib import form_utils
 from modoboa.lib import signals
@@ -136,7 +138,8 @@ class Manager(object):
         if not registry.exists(self._level, app, parameter):
             raise NotDefined(app, parameter)
         if app not in self._parameters:
-            self._parameters[app] = registry.get_defaults(self._level, app)
+            self._parameters[app] = copy.deepcopy(
+                registry.get_defaults(self._level, app))
         self._parameters[app][parameter] = value
 
     def set_values(self, values, app=None):
@@ -146,7 +149,8 @@ class Manager(object):
         if not registry.exists(self._level, app):
             raise NotDefined(app)
         if app not in self._parameters:
-            self._parameters[app] = registry.get_defaults(self._level, app)
+            self._parameters[app] = copy.deepcopy(
+                registry.get_defaults(self._level, app))
         self._parameters[app].update(values)