Add unit tests.

see #799
2026-10-17 05:41:25 +02:00 · 2016-04-27 10:19:20 +02:00
parent 90e46a85a7
commit cd6b30b2ed
2 changed files with 157 additions and 94 deletions
@@ -8,10 +8,12 @@ from django.contrib.contenttypes import generic

 import reversion

+from modoboa.core import models as core_models
+from modoboa.core import signals as core_signals
+from modoboa.lib.exceptions import BadRequest, Conflict
+
 from .base import AdminObject
 from .domain import Domain
-from modoboa.core import models as core_models
-from modoboa.lib.exceptions import BadRequest, Conflict


 class DomainAliasManager(models.Manager):
@@ -76,6 +78,8 @@ class DomainAlias(AdminObject):
            self.target = Domain.objects.get(name=domname)
        except Domain.DoesNotExist:
            raise BadRequest(_("Unknown domain %s") % domname)
+        core_signals.can_create_object.send(
+            sender="import", context=self.target, object_type="domain_aliases")
        self.enabled = row[3].strip() in ["True", "1", "yes", "y"]
        self.save(creator=user)

@@ -12,19 +12,128 @@ from modoboa.lib.tests import ModoTestCase
 from .. import utils


-class UserLimitImportTestCase(ModoTestCase):
+class LimitImportTestCase(ModoTestCase):
+    """Base class to test limits."""

    @classmethod
    def setUpTestData(cls):
        """Create test data."""
-        super(UserLimitImportTestCase, cls).setUpTestData()
-        for name, tpl in utils.get_user_limit_templates():
-            parameters.save_admin(
-                "DEFLT_USER_{}_LIMIT".format(name.upper()), 2)
+        super(LimitImportTestCase, cls).setUpTestData()
        admin_factories.populate_database()
        cls.reseller = core_factories.UserFactory(
            username="reseller", groups=("Resellers", ))
        cls.dadmin = core_models.User.objects.get(username="admin@test.com")
+        cls.domain = admin_models.Domain.objects.get(name="test.com")
+
+    def _test_domain_alias_import(self, limit):
+        """Check domain aliases limit."""
+        self.client.login(
+            username=self.reseller.username, password="toto")
+        self.assertFalse(limit.is_exceeded())
+        f = ContentFile(b"""domainalias; domalias1.com; {domain}; True
+domainalias; domalias2.com; {domain}; True
+""".format(domain=self.domain), name="domains.csv")
+        self.client.post(
+            reverse("admin:domain_import"), {
+                "sourcefile": f
+            }
+        )
+        self.assertTrue(limit.is_exceeded())
+
+        f = ContentFile(
+            "domainalias; domalias3.com; {}; True".format(self.domain),
+            name="domains.csv")
+        response = self.client.post(
+            reverse("admin:domain_import"), {
+                "sourcefile": f
+            }
+        )
+        self.assertContains(response, "Domain aliases: limit reached")
+
+    def _test_domain_admins_import(self, limit):
+        """Check domain admins limit."""
+        self.client.login(
+            username=self.reseller.username, password="toto")
+        self.assertFalse(limit.is_exceeded())
+        f = ContentFile(b"""account; admin1@{domain}; toto; User; One; True; DomainAdmins; user1@{domain}; 5; {domain}
+account; admin2@{domain}; toto; René; Truc; True; DomainAdmins; truc@{domain}; 5; {domain}
+""".format(domain=self.domain), name="domain_admins.csv")
+        self.client.post(
+            reverse("admin:identity_import"), {
+                "sourcefile": f
+            }
+        )
+        self.assertTrue(limit.is_exceeded())
+
+        f = ContentFile(b"""account; admin3@{domain}; toto; User; One; True; DomainAdmins; admin3@{domain}; 5; {domain}
+""".format(domain=self.domain), name="domain_admins.csv")
+        response = self.client.post(
+            reverse("admin:identity_import"), {
+                "sourcefile": f
+            }
+        )
+        self.assertContains(response, "Permission denied")
+
+    def _test_mailboxes_import(self, limit):
+        """Check mailboxes limit."""
+        self.client.login(
+            username=self.dadmin.username, password="toto")
+        self.assertFalse(limit.is_exceeded())
+        f = ContentFile(b"""account; user1@{domain}; toto; User; One; True; SimpleUsers; user1@{domain}; 5
+account; truc@{domain}; toto; René; Truc; True; SimpleUsers; truc@{domain}; 5
+""".format(domain=self.domain), name="domains.csv")
+        response = self.client.post(
+            reverse("admin:identity_import"), {
+                "sourcefile": f
+            }
+        )
+        self.assertTrue(limit.is_exceeded())
+
+        f = ContentFile("""
+account; user3@{domain}; toto; User; One; True; SimpleUsers; user3@{domain}; 5
+""".format(domain=self.domain), name="domains.csv")
+        response = self.client.post(
+            reverse("admin:identity_import"), {
+                "sourcefile": f
+            }
+        )
+        self.assertContains(response, "Mailboxes: limit reached")
+
+    def _test_mailbox_aliases_import(self, limit):
+        """Check mailbox aliases limit."""
+        self.client.login(
+            username=self.dadmin.username, password="toto")
+        self.assertFalse(limit.is_exceeded())
+        f = ContentFile(b"""alias; alias1@{domain}; True; user@{domain}
+alias; alias2@{domain}; True; user@{domain}
+""".format(domain=self.domain), name="aliases.csv")
+        response = self.client.post(
+            reverse("admin:identity_import"), {
+                "sourcefile": f
+            }
+        )
+        self.assertTrue(limit.is_exceeded())
+
+        f = ContentFile("""
+alias; alias3@{domain}; True; user@{domain}
+""".format(domain=self.domain), name="aliases.csv")
+        response = self.client.post(
+            reverse("admin:identity_import"), {
+                "sourcefile": f
+            }
+        )
+        self.assertContains(response, "Mailbox aliases: limit reached")
+
+
+class UserLimitImportTestCase(LimitImportTestCase):
+
+    @classmethod
+    def setUpTestData(cls):
+        """Create test data."""
+        for name, tpl in utils.get_user_limit_templates():
+            parameters.save_admin(
+                "DEFLT_USER_{}_LIMIT".format(name.upper()), 2)
+        super(UserLimitImportTestCase, cls).setUpTestData()

    def test_domains_import(self):
        """Check domains limit."""
@@ -53,104 +162,54 @@ domain; domain2.com; 200; False

    def test_domain_alias_import(self):
        """Check domain aliases limit."""
-        self.client.login(
-            username=self.reseller.username, password="toto")
        limit = self.reseller.userobjectlimit_set.get(name="domain_aliases")
-        self.assertFalse(limit.is_exceeded())
-        f = ContentFile(b"""domainalias; domalias1.com; test.com; True
-domainalias; domalias2.com; test.com; True
-""", name="domains.csv")
-        self.client.post(
-            reverse("admin:domain_import"), {
-                "sourcefile": f
-            }
-        )
-        self.assertTrue(limit.is_exceeded())
-
-        f = ContentFile(
-            "domainalias; domalias3.com; test.com; True", name="domains.csv")
-        response = self.client.post(
-            reverse("admin:domain_import"), {
-                "sourcefile": f
-            }
-        )
-        self.assertContains(response, "Domain aliases: limit reached")
+        self._test_domain_alias_import(limit)

    def test_domain_admins_import(self):
        """Check domain admins limit."""
-        self.client.login(
-            username=self.reseller.username, password="toto")
-        domain = admin_models.Domain.objects.get(name="test.com")
-        domain.add_admin(self.reseller)
+        self.domain.add_admin(self.reseller)
        limit = self.reseller.userobjectlimit_set.get(name="domain_admins")
-        self.assertFalse(limit.is_exceeded())
-        f = ContentFile(b"""account; admin1@test.com; toto; User; One; True; DomainAdmins; user1@test.com; 5; test.com
-account; admin2@test.com; toto; René; Truc; True; DomainAdmins; truc@test.com; 5; test.com
-""", name="domain_admins.csv")
-        self.client.post(
-            reverse("admin:identity_import"), {
-                "sourcefile": f
-            }
-        )
-        self.assertTrue(limit.is_exceeded())
-
-        f = ContentFile(b"""account; admin3@test.com; toto; User; One; True; DomainAdmins; admin3@test.com; 5; test.com
-""", name="domain_admins.csv")
-        response = self.client.post(
-            reverse("admin:identity_import"), {
-                "sourcefile": f
-            }
-        )
-        self.assertContains(response, "Permission denied")
+        self._test_domain_admins_import(limit)

    def test_mailboxes_import(self):
        """Check mailboxes limit."""
-        self.client.login(
-            username=self.dadmin.username, password="toto")
        limit = self.dadmin.userobjectlimit_set.get(name="mailboxes")
-        self.assertFalse(limit.is_exceeded())
-        f = ContentFile(b"""account; user1@test.com; toto; User; One; True; SimpleUsers; user1@test.com; 5
-account; truc@test.com; toto; René; Truc; True; SimpleUsers; truc@test.com; 5
-""", name="domains.csv")
-        self.client.post(
-            reverse("admin:identity_import"), {
-                "sourcefile": f
-            }
-        )
-        self.assertTrue(limit.is_exceeded())
-
-        f = ContentFile("""
-account; user3@test.com; toto; User; One; True; SimpleUsers; user3@test.com; 5
-""", name="domains.csv")
-        response = self.client.post(
-            reverse("admin:identity_import"), {
-                "sourcefile": f
-            }
-        )
-        self.assertContains(response, "Mailboxes: limit reached")
+        self._test_mailboxes_import(limit)

    def test_mailbox_aliases_import(self):
        """Check mailbox aliases limit."""
-        self.client.login(
-            username=self.dadmin.username, password="toto")
        limit = self.dadmin.userobjectlimit_set.get(name="mailbox_aliases")
-        self.assertFalse(limit.is_exceeded())
-        f = ContentFile(b"""alias; alias1@test.com; True; user@test.com
-alias; alias2@test.com; True; user@test.com
-""", name="aliases.csv")
-        self.client.post(
-            reverse("admin:identity_import"), {
-                "sourcefile": f
-            }
-        )
-        self.assertTrue(limit.is_exceeded())
+        self._test_mailbox_aliases_import(limit)

-        f = ContentFile("""
-alias; alias3@test.com; True; user@test.com
-""", name="aliases.csv")
-        response = self.client.post(
-            reverse("admin:identity_import"), {
-                "sourcefile": f
-            }
-        )
-        self.assertContains(response, "Mailbox aliases: limit reached")
+
+class DomainLimitImportTestCase(LimitImportTestCase):
+
+    @classmethod
+    def setUpTestData(cls):
+        """Create test data."""
+        parameters.save_admin("ENABLE_DOMAIN_LIMITS", "yes")
+        parameters.save_admin("ENABLE_ADMIN_LIMITS", "no")
+        for name, tpl in utils.get_domain_limit_templates():
+            parameters.save_admin(
+                "DEFLT_DOMAIN_{}_LIMIT".format(name.upper()), 2)
+        super(DomainLimitImportTestCase, cls).setUpTestData()
+        mb = admin_factories.MailboxFactory(
+            user__username="user@test4.com",
+            domain__name="test4.com", address="user")
+        cls.domain = mb.domain
+        cls.domain.add_admin(cls.dadmin)
+
+    def test_domain_alias_import(self):
+        """Check domain aliases limit."""
+        limit = self.domain.domainobjectlimit_set.get(name="domain_aliases")
+        self._test_domain_alias_import(limit)
+
+    def test_mailboxes_import(self):
+        """Check mailboxes limit."""
+        limit = self.domain.domainobjectlimit_set.get(name="mailboxes")
+        self._test_mailboxes_import(limit)
+
+    def test_mailbox_aliases_import(self):
+        """Check mailbox aliases limit."""
+        limit = self.domain.domainobjectlimit_set.get(name="mailbox_aliases")
+        self._test_mailbox_aliases_import(limit)