diff --git a/modoboa/extensions/admin/factories.py b/modoboa/extensions/admin/factories.py index f657e9979..9656a1dd2 100644 --- a/modoboa/extensions/admin/factories.py +++ b/modoboa/extensions/admin/factories.py @@ -1,4 +1,6 @@ import factory +from modoboa.core.models import User +from modoboa.core.factories import UserFactory from . import models @@ -18,3 +20,31 @@ class MailboxFactory(factory.DjangoModelFactory): class AliasFactory(factory.DjangoModelFactory): FACTORY_FOR = models.Alias + + +def populate_database(): + """Create test data. + + 2 domains, 1 domain admin, 2 users + """ + sa = User.objects.get(pk=1) + dom = DomainFactory.create(name="test.com") + admin = UserFactory( + username="admin@test.com", groups=('DomainAdmins',) + ) + admin.post_create(sa) + MailboxFactory(address='admin', domain=dom, user=admin) + account = UserFactory.create( + username="user@test.com", groups=('SimpleUsers',) + ) + account.post_create(sa) + MailboxFactory.create(address='user', domain=dom, user=account) + + dom2 = DomainFactory(name='test2.com') + u = UserFactory( + username='user@test2.com', groups=('SimpleUsers',) + ) + u.post_create(sa) + MailboxFactory(address='user', domain=dom2, user=u) + + dom.add_admin(admin) diff --git a/modoboa/extensions/admin/tests.py b/modoboa/extensions/admin/tests.py deleted file mode 100644 index aab6f8786..000000000 --- a/modoboa/extensions/admin/tests.py +++ /dev/null @@ -1,534 +0,0 @@ -# coding: utf-8 -""" -Basic tests for the 'admin' application -======================================= - -TODO: - -* Add new tests to check domain/mailbox manipulations when - create_directories == yes - -""" -from django.core.urlresolvers import reverse -from django.core.files.base import ContentFile -from modoboa.core.models import User -from modoboa.core.factories import UserFactory -from modoboa.lib.tests import ModoTestCase -from modoboa.extensions.admin.models import ( - Domain, Mailbox, Alias, DomainAlias -) -from . import factories - - -class DomainTestCase(ModoTestCase): - fixtures = ["initial_users.json"] - - def setUp(self): - super(DomainTestCase, self).setUp() - self.dom = factories.DomainFactory(name='test.com') - - def test_create(self): - """Test the creation of a domain - """ - values = { - "name": "pouet.com", "quota": 100, "create_dom_admin": "no", - "stepid": 2 - } - self.check_ajax_post(reverse("modoboa.extensions.admin.views.domain.newdomain"), values) - dom = Domain.objects.get(name="pouet.com") - self.assertEqual(dom.name, "pouet.com") - self.assertEqual(dom.quota, 100) - self.assertEqual(dom.enabled, False) - self.assertFalse(dom.admins) - - def test_create_with_template(self): - """Test the creation of a domain with a template - - """ - values = { - "name": "pouet.com", "quota": 100, "create_dom_admin": "yes", - "dom_admin_username": "toto", "create_aliases": "yes", - "stepid": 2 - } - self.check_ajax_post(reverse("modoboa.extensions.admin.views.domain.newdomain"), values) - dom = Domain.objects.get(name="pouet.com") - da = User.objects.get(username="toto@pouet.com") - self.assertIn(da, dom.admins) - al = Alias.objects.get(address="postmaster", domain__name="pouet.com") - self.assertIn(da.mailbox_set.all()[0], al.mboxes.all()) - self.assertTrue(da.can_access(al)) - - def test_create_with_template_and_empty_quota(self): - """Test the creation of a domain with a template and no quota""" - values = { - "name": "pouet.com", "quota": 0, "create_dom_admin": "yes", - "dom_admin_username": "toto", "create_aliases": "yes", - "stepid": 2 - } - self.check_ajax_post(reverse("modoboa.extensions.admin.views.domain.newdomain"), values) - dom = Domain.objects.get(name="pouet.com") - da = User.objects.get(username="toto@pouet.com") - self.assertIn(da, dom.admins) - al = Alias.objects.get(address="postmaster", domain__name="pouet.com") - self.assertIn(da.mailbox_set.all()[0], al.mboxes.all()) - self.assertTrue(da.can_access(al)) - - def test_modify(self): - """Test the modification of a domain - - Rename 'test.com' domain to 'pouet.com' - """ - values = { - "name": "pouet.com", "quota": 100, "enabled": True - } - self.check_ajax_post( - reverse("modoboa.extensions.admin.views.domain.editdomain", args=[self.dom.id]), - values - ) - dom = Domain.objects.get(name="pouet.com") - self.assertEqual(dom.name, "pouet.com") - self.assertTrue(dom.enabled) - - def test_delete(self): - """Test the removal of a domain - """ - self.check_ajax_get(reverse("modoboa.extensions.admin.views.domain.deldomain", args=[self.dom.id]), {}) - with self.assertRaises(Domain.DoesNotExist): - Domain.objects.get(pk=1) - - -class DomainAliasTestCase(ModoTestCase): - fixtures = ['initial_users.json'] - - def setUp(self): - super(DomainAliasTestCase, self).setUp() - self.dom = factories.DomainFactory(name='test.com') - - def test_model(self): - dom = Domain.objects.get(name="test.com") - domal = DomainAlias() - domal.name = "domalias.net" - domal.target = dom - domal.save() - self.assertEqual(dom.domainalias_count, 1) - - domal.name = "domalias.org" - domal.save() - - domal.delete() - - def test_form(self): - dom = Domain.objects.get(name="test.com") - values = dict(name=dom.name, quota=dom.quota, enabled=dom.enabled, - aliases="domalias.net", aliases_1="domalias.com") - self.check_ajax_post(reverse("modoboa.extensions.admin.views.domain.editdomain", args=[dom.id]), values) - self.assertEqual(dom.domainalias_set.count(), 2) - - del values["aliases_1"] - self.check_ajax_post(reverse("modoboa.extensions.admin.views.domain.editdomain", args=[dom.id]), values) - self.assertEqual(dom.domainalias_set.count(), 1) - - -class AccountTestCase(ModoTestCase): - fixtures = ["initial_users.json"] - - def setUp(self): - super(AccountTestCase, self).setUp() - self.dom = factories.DomainFactory(name="test.com") - self.account = UserFactory( - username="user@test.com", groups=('SimpleUsers',) - ) - factories.MailboxFactory(address='user', domain=self.dom, user=self.account) - - def test_crud(self): - values = dict(username="tester@test.com", first_name="Tester", last_name="Toto", - password1="toto", password2="toto", role="SimpleUsers", - quota_act=True, - is_active=True, email="tester@test.com", stepid=2) - self.check_ajax_post(reverse("modoboa.extensions.admin.views.identity.newaccount"), values) - - account = User.objects.get(username="tester@test.com") - mb = account.mailbox_set.all()[0] - self.assertEqual(mb.full_address, "tester@test.com") - self.assertEqual(mb.quota, 10) - self.assertEqual(mb.enabled, True) - self.assertEqual(mb.quota_value.username, "tester@test.com") - self.assertEqual(account.username, mb.full_address) - self.assertTrue(account.check_password("toto")) - self.assertEqual(account.first_name, "Tester") - self.assertEqual(account.last_name, "Toto") - self.assertEqual(mb.domain.mailbox_count, 2) - - values["username"] = "pouet@test.com" - self.check_ajax_post(reverse("modoboa.extensions.admin.views.identity.editaccount", args=[account.id]), values) - - mb = Mailbox.objects.get(pk=mb.id) - self.assertEqual(mb.full_address, "pouet@test.com") - - self.check_ajax_get(reverse("modoboa.extensions.admin.views.identity.delaccount", args=[account.id]), {}) - - -class AliasTestCase(ModoTestCase): - fixtures = ["initial_users.json"] - - def setUp(self): - super(AliasTestCase, self).setUp() - dom = factories.DomainFactory(name="test.com") - u = UserFactory.create( - username="admin@test.com", groups=('DomainAdmins',) - ) - factories.MailboxFactory(address='admin', domain=dom, user=u) - u = UserFactory.create( - username="user@test.com", groups=('SimpleUsers',) - ) - factories.MailboxFactory(address='user', domain=dom, user=u) - - def test_alias(self): - user = User.objects.get(username="user@test.com") - values = dict( - username="user@test.com", role=user.group, - is_active=user.is_active, email="user@test.com", - aliases="toto@test.com", aliases_1="titi@test.com" - ) - self.check_ajax_post(reverse("modoboa.extensions.admin.views.identity.editaccount", args=[user.id]), values) - self.assertEqual(user.mailbox_set.all()[0].alias_set.count(), 2) - - del values["aliases_1"] - self.check_ajax_post(reverse("modoboa.extensions.admin.views.identity.editaccount", args=[user.id]), values) - self.assertEqual(user.mailbox_set.all()[0].alias_set.count(), 1) - - def test_dlist(self): - values = dict(email="all@test.com", - recipients="user@test.com", - recipients_1="admin@test.com", - recipients_2="ext@titi.com", - enabled=True) - self.check_ajax_post(reverse("modoboa.extensions.admin.views.alias.newdlist"), values) - user = User.objects.get(username="user@test.com") - self.assertEqual(len(user.mailbox_set.all()[0].alias_set.all()), 1) - admin = User.objects.get(username="admin@test.com") - self.assertEqual(len(admin.mailbox_set.all()[0].alias_set.all()), 1) - - dlist = Alias.objects.get(address="all", domain__name="test.com") - self.assertEqual(len(dlist.get_recipients()), 3) - del values["recipients_1"] - self.check_ajax_post(reverse("modoboa.extensions.admin.views.alias.editalias", args=[dlist.id]), - values) - self.assertEqual(dlist.get_recipients_count(), 2) - - self.check_ajax_get(reverse("modoboa.extensions.admin.views.alias.delalias") + "?selection=%d" \ - % dlist.id, {}) - self.assertRaises(Alias.DoesNotExist, Alias.objects.get, - address="all", domain__name="test.com") - - def test_forward(self): - values = dict(email="forward@test.com", recipients="rcpt@dest.com") - self.check_ajax_post(reverse("modoboa.extensions.admin.views.alias.newforward"), values) - fwd = Alias.objects.get(address="forward", domain__name="test.com") - self.assertEqual(fwd.get_recipients_count(), 1) - - values["recipients"] = "rcpt2@dest.com" - self.check_ajax_post(reverse("modoboa.extensions.admin.views.alias.editalias", args=[fwd.id]), - values) - self.assertEqual(fwd.get_recipients_count(), 1) - - self.check_ajax_get(reverse("modoboa.extensions.admin.views.alias.delalias") + "?selection=%d" \ - % fwd.id, {}) - self.assertRaises(Alias.DoesNotExist, Alias.objects.get, - address="forward", domain__name="test.com") - - def test_forward_and_local_copies(self): - values = dict(email="user@test.com", recipients="rcpt@dest.com") - self.check_ajax_post(reverse("modoboa.extensions.admin.views.alias.newforward"), values) - fwd = Alias.objects.get(address="user", domain__name="test.com") - self.assertEqual(fwd.get_recipients_count(), 1) - - values["recipients"] = "rcpt@dest.com" - values["recipients_1"] = "user@test.com" - self.check_ajax_post(reverse("modoboa.extensions.admin.views.alias.editalias", args=[fwd.id]), - values) - fwd = Alias.objects.get(pk=fwd.pk) - self.assertEqual(fwd.get_recipients_count(), 2) - self.assertEqual(fwd.aliases.count(), 0) - - -class PermissionsTestCase(ModoTestCase): - fixtures = ["initial_users.json"] - - def setUp(self): - super(PermissionsTestCase, self).setUp() - dom = factories.DomainFactory(name='test.com') - self.user = UserFactory( - username="user@test.com", groups=('SimpleUsers',) - ) - factories.MailboxFactory(address='user', domain=dom, user=self.user) - self.values = dict( - username=self.user.username, role="DomainAdmins", - is_active=self.user.is_active, email="user@test.com" - ) - self.admin = UserFactory( - username="admin@test.com", groups=('DomainAdmins',) - ) - factories.MailboxFactory(address='admin', domain=dom, user=self.admin) - dom.add_admin(self.admin) - - dom = factories.DomainFactory(name='test2.com') - u = UserFactory( - username='user@test2.com', groups=('SimpleUsers',) - ) - factories.MailboxFactory(address='user', domain=dom, user=u) - - def tearDown(self): - self.clt.logout() - - def test_domain_admins(self): - self.values["role"] = "DomainAdmins" - self.check_ajax_post(reverse("modoboa.extensions.admin.views.identity.editaccount", args=[self.user.id]), - self.values) - self.assertEqual(self.user.group == "DomainAdmins", True) - - self.values["role"] = "SimpleUsers" - self.check_ajax_post(reverse("modoboa.extensions.admin.views.identity.editaccount", args=[self.user.id]), - self.values) - self.assertEqual(self.user.group == 'DomainAdmins', False) - - def test_superusers(self): - self.values["role"] = "SuperAdmins" - self.check_ajax_post(reverse("modoboa.extensions.admin.views.identity.editaccount", args=[self.user.id]), - self.values) - self.assertEqual(User.objects.get(username="user@test.com").is_superuser, True) - - self.values["role"] = "SimpleUsers" - self.check_ajax_post(reverse("modoboa.extensions.admin.views.identity.editaccount", args=[self.user.id]), - self.values) - self.assertEqual(User.objects.get(username="user@test.com").is_superuser, False) - - def test_self_modif(self): - self.clt.logout() - self.assertEqual(self.clt.login(username="admin@test.com", password="toto"), - True) - admin = User.objects.get(username="admin@test.com") - values = dict(username="admin@test.com", first_name="Admin", password1="", password2="", - quota=10, is_active=True, email="admin@test.com") - self.check_ajax_post(reverse("modoboa.extensions.admin.views.identity.editaccount", args=[admin.id]), values) - self.assertEqual(admin.group, "DomainAdmins") - self.assertEqual(admin.can_access(Domain.objects.get(name="test.com")), True) - - values["role"] = "SuperAdmins" - self.check_ajax_post(reverse("modoboa.extensions.admin.views.identity.editaccount", args=[admin.id]), values) - admin = User.objects.get(username="admin@test.com") - self.assertEqual(admin.group, "DomainAdmins") - - def test_domadmin_access(self): - self.clt.logout() - self.assertEqual(self.clt.login(username="admin@test.com", password="toto"), - True) - response = self.clt.get(reverse("modoboa.extensions.admin.views.domain.domains")) - self.assertEqual(response.status_code, 200) - - user = User.objects.get(username="user@test.com") - response = self.clt.get(reverse("modoboa.extensions.admin.views.identity.editaccount", args=[user.id]), - HTTP_X_REQUESTED_WITH='XMLHttpRequest') - self.assertNotEqual(response["Content-Type"], "application/json") - - def test_domainadmin_deletes_superadmin(self): - """Check domain admins restrictions about super admins - - When a super admin owns a mailbox and a domain admin exists - for the associated domain, this domain admin must not be able - to access the super admin. - """ - values = dict(username="superadmin2@test.com", first_name="Super", last_name="Admin", - password1="toto", password2="toto", role="SuperAdmins", - is_active=True, email="superadmin2@test.com", stepid=2) - self.check_ajax_post(reverse("modoboa.extensions.admin.views.identity.newaccount"), values) - - account = User.objects.get(username="superadmin2@test.com") - self.clt.logout() - self.clt.login(username="admin@test.com", password="toto") - self.check_ajax_get(reverse("modoboa.extensions.admin.views.identity.delaccount", args=[account.id]), {}, - status="ko", respmsg="Permission denied") - self.check_ajax_get(reverse("modoboa.extensions.admin.views.identity.delaccount", args=[account.id]), {}, - status="ko", respmsg="Permission denied") - - def test_domainadmin_dlist_local_domain_not_owned(self): - """Check if a domain admin can use a local mailbox he can't - access as a recipient in a distribution list""" - values = dict( - email="all@test.com", - recipients="user@test.com", - recipients_1="user@test2.com", - enabled=True - ) - self.check_ajax_post(reverse("modoboa.extensions.admin.views.alias.newdlist"), values) - - -class ImportTestCase(ModoTestCase): - fixtures = ["initial_users.json"] - - def setUp(self): - super(ImportTestCase, self).setUp() - dom = factories.DomainFactory(name="test.com") - self.admin = UserFactory.create( - username="admin@test.com", groups=('DomainAdmins',) - ) - factories.MailboxFactory(address='admin', domain=dom, user=self.admin) - dom.add_admin(self.admin) - u = UserFactory.create( - username="user@test.com", groups=('SimpleUsers',) - ) - factories.MailboxFactory(address='user', domain=dom, user=u) - - def test_domains_import(self): - f = ContentFile(b"""domain; domain1.com; 100; True -domain; domain2.com; 200; False -domainalias; domalias1.com; domain1.com; True -""", name="domains.csv") - self.clt.post(reverse("modoboa.extensions.admin.views.import.import_domains"), { - "sourcefile": f - }) - admin = User.objects.get(username="admin") - dom = Domain.objects.get(name="domain1.com") - self.assertEqual(dom.quota, 100) - self.assertTrue(dom.enabled) - self.assertTrue(admin.is_owner(dom)) - domalias = DomainAlias.objects.get(name="domalias1.com") - self.assertEqual(domalias.target, dom) - self.assertTrue(dom.enabled) - self.assertTrue(admin.is_owner(domalias)) - dom = Domain.objects.get(name="domain2.com") - self.assertEqual(dom.quota, 200) - self.assertFalse(dom.enabled) - self.assertTrue(admin.is_owner(dom)) - - def test_identities_import(self): - f = ContentFile(b""" -account; user1@test.com; toto; User; One; True; SimpleUsers; user1@test.com -account; truc@test.com; toto; René; Truc; True; DomainAdmins; truc@test.com; test.com -alias; alias1@test.com; True; user1@test.com -forward; fwd1@test.com; True; user@extdomain.com -dlist; dlist@test.com; True; user1@test.com; user@extdomain.com -""", name="identities.csv") - self.clt.post(reverse("modoboa.extensions.admin.views.import.import_identities"), { - "sourcefile": f, "crypt_password": True - }) - admin = User.objects.get(username="admin") - u1 = User.objects.get(username="user1@test.com") - self.assertTrue(admin.is_owner(u1)) - self.assertEqual(u1.email, "user1@test.com") - self.assertEqual(u1.first_name, "User") - self.assertEqual(u1.last_name, "One") - self.assertTrue(u1.is_active) - self.assertEqual(u1.group, "SimpleUsers") - self.assertTrue(admin.is_owner(u1.mailbox_set.all()[0])) - self.assertEqual(u1.mailbox_set.all()[0].full_address, "user1@test.com") - self.assertTrue(self.clt.login(username="user1@test.com", password="toto")) - - da = User.objects.get(username="truc@test.com") - self.assertEqual(da.first_name, u"René") - self.assertEqual(da.group, "DomainAdmins") - self.assertEqual(da.mailbox_set.all()[0].full_address, "truc@test.com") - dom = Domain.objects.get(name="test.com") - self.assertIn(da, dom.admins) - u = User.objects.get(username="user@test.com") - self.assertTrue(da.can_access(u)) - - al = Alias.objects.get(address="alias1", domain__name="test.com") - self.assertIn(u1.mailbox_set.all()[0], al.mboxes.all()) - self.assertTrue(admin.is_owner(al)) - - fwd = Alias.objects.get(address="fwd1", domain__name="test.com") - self.assertIn("user@extdomain.com", fwd.extmboxes) - self.assertTrue(admin.is_owner(fwd)) - - dlist = Alias.objects.get(address="dlist", domain__name="test.com") - self.assertIn(u1.mailbox_set.all()[0], dlist.mboxes.all()) - self.assertIn("user@extdomain.com", dlist.extmboxes) - self.assertTrue(admin.is_owner(dlist)) - - def test_import_duplicate(self): - f = ContentFile(b""" -account; admin@test.com; toto; Admin; ; True; DomainAdmins; admin@test.com; test.com -account; truc@test.com; toto; René; Truc; True; DomainAdmins; truc@test.com; test.com -""", name="identities.csv") - self.clt.post(reverse("modoboa.extensions.admin.views.import.import_identities"), { - "sourcefile": f, "crypt_password": True, "continue_if_exists": True - }) - - admin = User.objects.get(username="admin") - u1 = User.objects.get(username="truc@test.com") - self.assertTrue(admin.is_owner(u1)) - - def test_import_superadmin(self): - """Check if a domain admin can import a superadmin - - Expected result: no - """ - self.clt.logout() - self.assertTrue(self.clt.login(username="admin@test.com", password="toto")) - f = ContentFile(b""" -account; sa@test.com; toto; Super; Admin; True; SuperAdmins; superadmin@test.com -""", name="identities.csv") - self.clt.post(reverse("modoboa.extensions.admin.views.import.import_identities"), { - "sourcefile": f, "crypt_password": True, "continue_if_exists": True - }) - with self.assertRaises(User.DoesNotExist): - User.objects.get(username="sa@test.com") - - -class ExportTestCase(ModoTestCase): - fixtures = ["initial_users.json"] - - def setUp(self): - super(ExportTestCase, self).setUp() - sa = User.objects.get(pk=1) - dom = factories.DomainFactory(name="test.com") - self.admin = UserFactory.create( - username="admin@test.com", groups=('DomainAdmins',) - ) - self.admin.post_create(sa) - factories.MailboxFactory(address='admin', domain=dom, user=self.admin) - dom.add_admin(self.admin) - u = UserFactory.create( - username="user@test.com", groups=('SimpleUsers',) - ) - u.post_create(sa) - factories.MailboxFactory(address='user', domain=dom, user=u) - # factories.AliasFactory( - # address='forward', domain=dom, extmboxes='user@extdomain.com' - # ) - - def __export_identities(self, idtfilter="", grpfilter=""): - self.clt.get( - reverse("modoboa.extensions.admin.views.identity._identities") \ - + "?grpfilter=%s&idtfilter=%s" % (grpfilter, idtfilter) - ) - return self.clt.post( - reverse("modoboa.extensions.admin.views.export.export_identities"), - {"filename": "test.csv"} - ) - - def test_export_identities(self): - response = self.__export_identities() - self.assertEqual(response.content, "account;admin;{CRYPT}dTTsGDkA5ZHKg;;;True;SuperAdmins;\r\naccount;admin@test.com;{PLAIN}toto;;;True;DomainAdmins;admin@test.com;test.com\r\naccount;user@test.com;{PLAIN}toto;;;True;SimpleUsers;user@test.com\r\n") - - def test_export_simpleusers(self): - response = self.__export_identities(grpfilter="SimpleUsers") - self.assertEqual( - response.content.strip(), - "account;user@test.com;{PLAIN}toto;;;True;SimpleUsers;user@test.com" - ) - - def test_export_superadmins(self): - response = self.__export_identities(grpfilter="SuperAdmins") - self.assertEqual( - response.content.strip(), - "account;admin;{CRYPT}dTTsGDkA5ZHKg;;;True;SuperAdmins;" - ) - - def test_export_domainadmins(self): - response = self.__export_identities(grpfilter="DomainAdmins") - self.assertEqual( - response.content.strip(), - "account;admin@test.com;{PLAIN}toto;;;True;DomainAdmins;admin@test.com;test.com" - ) diff --git a/modoboa/extensions/admin/tests/__init__.py b/modoboa/extensions/admin/tests/__init__.py new file mode 100644 index 000000000..9ee5833ef --- /dev/null +++ b/modoboa/extensions/admin/tests/__init__.py @@ -0,0 +1,12 @@ +from .domain import DomainTestCase +from .domain_alias import DomainAliasTestCase +from .account import AccountTestCase, PermissionsTestCase +from .alias import AliasTestCase +from .import_ import ImportTestCase +from .export import ExportTestCase + +__all__ = [ + 'DomainTestCase', 'DomainAliasTestCase', 'AccountTestCase', + 'PermissionsTestCase', 'AliasTestCase', 'ImportTestCase', + 'ExportTestCase' +] diff --git a/modoboa/extensions/admin/tests/account.py b/modoboa/extensions/admin/tests/account.py new file mode 100644 index 000000000..42b0f767f --- /dev/null +++ b/modoboa/extensions/admin/tests/account.py @@ -0,0 +1,190 @@ +from django.core.urlresolvers import reverse +from modoboa.core.models import User +from modoboa.lib.tests import ModoTestCase +from modoboa.extensions.admin.models import ( + Domain, Mailbox +) +from modoboa.extensions.admin import factories + + +class AccountTestCase(ModoTestCase): + fixtures = ["initial_users.json"] + + def setUp(self): + super(AccountTestCase, self).setUp() + factories.populate_database() + + def test_crud(self): + values = dict( + username="tester@test.com", first_name="Tester", last_name="Toto", + password1="toto", password2="toto", role="SimpleUsers", + quota_act=True, + is_active=True, email="tester@test.com", stepid=2 + ) + self.check_ajax_post( + reverse("modoboa.extensions.admin.views.identity.newaccount"), + values + ) + + account = User.objects.get(username="tester@test.com") + mb = account.mailbox_set.all()[0] + self.assertEqual(mb.full_address, "tester@test.com") + self.assertEqual(mb.quota, 10) + self.assertEqual(mb.enabled, True) + self.assertEqual(mb.quota_value.username, "tester@test.com") + self.assertEqual(account.username, mb.full_address) + self.assertTrue(account.check_password("toto")) + self.assertEqual(account.first_name, "Tester") + self.assertEqual(account.last_name, "Toto") + self.assertEqual(mb.domain.mailbox_count, 3) + + values["username"] = "pouet@test.com" + self.check_ajax_post( + reverse("modoboa.extensions.admin.views.identity.editaccount", + args=[account.id]), + values + ) + mb = Mailbox.objects.get(pk=mb.id) + self.assertEqual(mb.full_address, "pouet@test.com") + self.check_ajax_get( + reverse("modoboa.extensions.admin.views.identity.delaccount", + args=[account.id]), + {} + ) + + +class PermissionsTestCase(ModoTestCase): + fixtures = ["initial_users.json"] + + def setUp(self): + super(PermissionsTestCase, self).setUp() + factories.populate_database() + self.user = User.objects.get(username='user@test.com') + self.values = dict( + username=self.user.username, role="DomainAdmins", + is_active=self.user.is_active, email="user@test.com" + ) + + def tearDown(self): + self.clt.logout() + + def test_domain_admins(self): + self.values["role"] = "DomainAdmins" + self.check_ajax_post( + reverse("modoboa.extensions.admin.views.identity.editaccount", + args=[self.user.id]), + self.values + ) + self.assertEqual(self.user.group == "DomainAdmins", True) + + self.values["role"] = "SimpleUsers" + self.check_ajax_post( + reverse("modoboa.extensions.admin.views.identity.editaccount", + args=[self.user.id]), + self.values + ) + self.assertEqual(self.user.group == 'DomainAdmins', False) + + def test_superusers(self): + self.values["role"] = "SuperAdmins" + self.check_ajax_post( + reverse("modoboa.extensions.admin.views.identity.editaccount", + args=[self.user.id]), + self.values + ) + self.assertEqual(User.objects.get(username="user@test.com").is_superuser, True) + + self.values["role"] = "SimpleUsers" + self.check_ajax_post( + reverse("modoboa.extensions.admin.views.identity.editaccount", + args=[self.user.id]), + self.values + ) + self.assertEqual(User.objects.get(username="user@test.com").is_superuser, False) + + def test_self_modif(self): + self.clt.logout() + self.assertEqual(self.clt.login(username="admin@test.com", password="toto"), + True) + admin = User.objects.get(username="admin@test.com") + values = dict( + username="admin@test.com", first_name="Admin", + password1="", password2="", + quota=10, is_active=True, email="admin@test.com" + ) + self.check_ajax_post( + reverse("modoboa.extensions.admin.views.identity.editaccount", + args=[admin.id]), + values + ) + self.assertEqual(admin.group, "DomainAdmins") + self.assertEqual(admin.can_access(Domain.objects.get(name="test.com")), True) + + values["role"] = "SuperAdmins" + self.check_ajax_post( + reverse("modoboa.extensions.admin.views.identity.editaccount", + args=[admin.id]), + values + ) + admin = User.objects.get(username="admin@test.com") + self.assertEqual(admin.group, "DomainAdmins") + + def test_domadmin_access(self): + self.clt.logout() + self.assertEqual(self.clt.login(username="admin@test.com", password="toto"), + True) + response = self.clt.get( + reverse("modoboa.extensions.admin.views.domain.domains") + ) + self.assertEqual(response.status_code, 200) + + response = self.clt.get( + reverse("modoboa.extensions.admin.views.identity.editaccount", + args=[self.user.id]), + HTTP_X_REQUESTED_WITH='XMLHttpRequest') + self.assertNotEqual(response["Content-Type"], "application/json") + + def test_domainadmin_deletes_superadmin(self): + """Check domain admins restrictions about super admins + + When a super admin owns a mailbox and a domain admin exists + for the associated domain, this domain admin must not be able + to access the super admin. + """ + values = dict( + username="superadmin2@test.com", first_name="Super", + last_name="Admin", password1="toto", password2="toto", + role="SuperAdmins", is_active=True, + email="superadmin2@test.com", stepid=2 + ) + self.check_ajax_post( + reverse("modoboa.extensions.admin.views.identity.newaccount"), + values + ) + account = User.objects.get(username="superadmin2@test.com") + self.clt.logout() + self.clt.login(username="admin@test.com", password="toto") + self.check_ajax_get( + reverse("modoboa.extensions.admin.views.identity.delaccount", + args=[account.id]), + {}, + status="ko", respmsg="Permission denied" + ) + self.check_ajax_get( + reverse("modoboa.extensions.admin.views.identity.delaccount", + args=[account.id]), {}, + status="ko", respmsg="Permission denied" + ) + + def test_domainadmin_dlist_local_domain_not_owned(self): + """Check if a domain admin can use a local mailbox he can't + access as a recipient in a distribution list""" + values = dict( + email="all@test.com", + recipients="user@test.com", + recipients_1="user@test2.com", + enabled=True + ) + self.check_ajax_post( + reverse("modoboa.extensions.admin.views.alias.newdlist"), values + ) diff --git a/modoboa/extensions/admin/tests/alias.py b/modoboa/extensions/admin/tests/alias.py new file mode 100644 index 000000000..dc715d352 --- /dev/null +++ b/modoboa/extensions/admin/tests/alias.py @@ -0,0 +1,109 @@ +from django.core.urlresolvers import reverse +from modoboa.core.models import User +from modoboa.lib.tests import ModoTestCase +from modoboa.extensions.admin.models import ( + Alias +) +from modoboa.extensions.admin import factories + + +class AliasTestCase(ModoTestCase): + fixtures = ["initial_users.json"] + + def setUp(self): + super(AliasTestCase, self).setUp() + factories.populate_database() + + def test_alias(self): + user = User.objects.get(username="user@test.com") + values = dict( + username="user@test.com", role=user.group, + is_active=user.is_active, email="user@test.com", + aliases="toto@test.com", aliases_1="titi@test.com" + ) + self.check_ajax_post( + reverse("modoboa.extensions.admin.views.identity.editaccount", + args=[user.id]), + values + ) + self.assertEqual(user.mailbox_set.all()[0].alias_set.count(), 2) + + del values["aliases_1"] + self.check_ajax_post( + reverse("modoboa.extensions.admin.views.identity.editaccount", + args=[user.id]), + values + ) + self.assertEqual(user.mailbox_set.all()[0].alias_set.count(), 1) + + def test_dlist(self): + values = dict(email="all@test.com", + recipients="user@test.com", + recipients_1="admin@test.com", + recipients_2="ext@titi.com", + enabled=True) + self.check_ajax_post( + reverse("modoboa.extensions.admin.views.alias.newdlist"), values + ) + user = User.objects.get(username="user@test.com") + self.assertEqual(len(user.mailbox_set.all()[0].alias_set.all()), 1) + admin = User.objects.get(username="admin@test.com") + self.assertEqual(len(admin.mailbox_set.all()[0].alias_set.all()), 1) + + dlist = Alias.objects.get(address="all", domain__name="test.com") + self.assertEqual(len(dlist.get_recipients()), 3) + del values["recipients_1"] + self.check_ajax_post( + reverse("modoboa.extensions.admin.views.alias.editalias", + args=[dlist.id]), + values + ) + self.assertEqual(dlist.get_recipients_count(), 2) + + self.check_ajax_get( + reverse("modoboa.extensions.admin.views.alias.delalias") + "?selection=%d" \ + % dlist.id, {} + ) + self.assertRaises(Alias.DoesNotExist, Alias.objects.get, + address="all", domain__name="test.com") + + def test_forward(self): + values = dict(email="forward@test.com", recipients="rcpt@dest.com") + self.check_ajax_post( + reverse("modoboa.extensions.admin.views.alias.newforward"), values + ) + fwd = Alias.objects.get(address="forward", domain__name="test.com") + self.assertEqual(fwd.get_recipients_count(), 1) + + values["recipients"] = "rcpt2@dest.com" + self.check_ajax_post( + reverse("modoboa.extensions.admin.views.alias.editalias", + args=[fwd.id]), + values + ) + self.assertEqual(fwd.get_recipients_count(), 1) + + self.check_ajax_get( + reverse("modoboa.extensions.admin.views.alias.delalias") + "?selection=%d" \ + % fwd.id, {} + ) + self.assertRaises(Alias.DoesNotExist, Alias.objects.get, + address="forward", domain__name="test.com") + + def test_forward_and_local_copies(self): + values = dict(email="user@test.com", recipients="rcpt@dest.com") + self.check_ajax_post( + reverse("modoboa.extensions.admin.views.alias.newforward"), values + ) + fwd = Alias.objects.get(address="user", domain__name="test.com") + self.assertEqual(fwd.get_recipients_count(), 1) + + values["recipients"] = "rcpt@dest.com" + values["recipients_1"] = "user@test.com" + self.check_ajax_post( + reverse("modoboa.extensions.admin.views.alias.editalias", args=[fwd.id]), + values + ) + fwd = Alias.objects.get(pk=fwd.pk) + self.assertEqual(fwd.get_recipients_count(), 2) + self.assertEqual(fwd.aliases.count(), 0) diff --git a/modoboa/extensions/admin/tests/domain.py b/modoboa/extensions/admin/tests/domain.py new file mode 100644 index 000000000..234e0f117 --- /dev/null +++ b/modoboa/extensions/admin/tests/domain.py @@ -0,0 +1,97 @@ +from django.core.urlresolvers import reverse +from modoboa.core.models import User +from modoboa.lib.tests import ModoTestCase +from modoboa.extensions.admin.models import ( + Domain, Alias +) +from modoboa.extensions.admin import factories + + +class DomainTestCase(ModoTestCase): + fixtures = ["initial_users.json"] + + def setUp(self): + super(DomainTestCase, self).setUp() + factories.populate_database() + + def test_create(self): + """Test the creation of a domain + """ + values = { + "name": "pouet.com", "quota": 100, "create_dom_admin": "no", + "stepid": 2 + } + self.check_ajax_post(reverse("modoboa.extensions.admin.views.domain.newdomain"), values) + dom = Domain.objects.get(name="pouet.com") + self.assertEqual(dom.name, "pouet.com") + self.assertEqual(dom.quota, 100) + self.assertEqual(dom.enabled, False) + self.assertFalse(dom.admins) + + def test_create_with_template(self): + """Test the creation of a domain with a template + + """ + values = { + "name": "pouet.com", "quota": 100, "create_dom_admin": "yes", + "dom_admin_username": "toto", "create_aliases": "yes", + "stepid": 2 + } + self.check_ajax_post( + reverse("modoboa.extensions.admin.views.domain.newdomain"), + values + ) + dom = Domain.objects.get(name="pouet.com") + da = User.objects.get(username="toto@pouet.com") + self.assertIn(da, dom.admins) + al = Alias.objects.get(address="postmaster", domain__name="pouet.com") + self.assertIn(da.mailbox_set.all()[0], al.mboxes.all()) + self.assertTrue(da.can_access(al)) + + def test_create_with_template_and_empty_quota(self): + """Test the creation of a domain with a template and no quota""" + values = { + "name": "pouet.com", "quota": 0, "create_dom_admin": "yes", + "dom_admin_username": "toto", "create_aliases": "yes", + "stepid": 2 + } + self.check_ajax_post( + reverse("modoboa.extensions.admin.views.domain.newdomain"), + values + ) + dom = Domain.objects.get(name="pouet.com") + da = User.objects.get(username="toto@pouet.com") + self.assertIn(da, dom.admins) + al = Alias.objects.get(address="postmaster", domain__name="pouet.com") + self.assertIn(da.mailbox_set.all()[0], al.mboxes.all()) + self.assertTrue(da.can_access(al)) + + def test_modify(self): + """Test the modification of a domain + + Rename 'test.com' domain to 'pouet.com' + """ + values = { + "name": "pouet.com", "quota": 100, "enabled": True + } + dom = Domain.objects.get(name="test.com") + self.check_ajax_post( + reverse("modoboa.extensions.admin.views.domain.editdomain", + args=[dom.id]), + values + ) + dom = Domain.objects.get(name="pouet.com") + self.assertEqual(dom.name, "pouet.com") + self.assertTrue(dom.enabled) + + def test_delete(self): + """Test the removal of a domain + """ + dom = Domain.objects.get(name="test.com") + self.check_ajax_get( + reverse("modoboa.extensions.admin.views.domain.deldomain", + args=[dom.id]), + {} + ) + with self.assertRaises(Domain.DoesNotExist): + Domain.objects.get(pk=1) diff --git a/modoboa/extensions/admin/tests/domain_alias.py b/modoboa/extensions/admin/tests/domain_alias.py new file mode 100644 index 000000000..d79e2a645 --- /dev/null +++ b/modoboa/extensions/admin/tests/domain_alias.py @@ -0,0 +1,47 @@ +from django.core.urlresolvers import reverse +from modoboa.lib.tests import ModoTestCase +from modoboa.extensions.admin.models import ( + Domain, DomainAlias +) +from modoboa.extensions.admin import factories + + +class DomainAliasTestCase(ModoTestCase): + fixtures = ['initial_users.json'] + + def setUp(self): + super(DomainAliasTestCase, self).setUp() + factories.populate_database() + self.dom = Domain.objects.get(name='test.com') + + def test_model(self): + dom = Domain.objects.get(name="test.com") + domal = DomainAlias() + domal.name = "domalias.net" + domal.target = dom + domal.save() + self.assertEqual(dom.domainalias_count, 1) + + domal.name = "domalias.org" + domal.save() + + domal.delete() + + def test_form(self): + dom = Domain.objects.get(name="test.com") + values = dict(name=dom.name, quota=dom.quota, enabled=dom.enabled, + aliases="domalias.net", aliases_1="domalias.com") + self.check_ajax_post( + reverse("modoboa.extensions.admin.views.domain.editdomain", + args=[dom.id]), + values + ) + self.assertEqual(dom.domainalias_set.count(), 2) + + del values["aliases_1"] + self.check_ajax_post( + reverse("modoboa.extensions.admin.views.domain.editdomain", + args=[dom.id]), + values + ) + self.assertEqual(dom.domainalias_set.count(), 1) diff --git a/modoboa/extensions/admin/tests/export.py b/modoboa/extensions/admin/tests/export.py new file mode 100644 index 000000000..c0fb42dbe --- /dev/null +++ b/modoboa/extensions/admin/tests/export.py @@ -0,0 +1,46 @@ +from django.core.urlresolvers import reverse +from modoboa.lib.tests import ModoTestCase +from modoboa.extensions.admin import factories + + +class ExportTestCase(ModoTestCase): + fixtures = ["initial_users.json"] + + def setUp(self): + super(ExportTestCase, self).setUp() + factories.populate_database() + + def __export_identities(self, idtfilter="", grpfilter=""): + self.clt.get( + reverse("modoboa.extensions.admin.views.identity._identities") \ + + "?grpfilter=%s&idtfilter=%s" % (grpfilter, idtfilter) + ) + return self.clt.post( + reverse("modoboa.extensions.admin.views.export.export_identities"), + {"filename": "test.csv"} + ) + + def test_export_identities(self): + response = self.__export_identities() + self.assertEqual(response.content, "account;admin;{CRYPT}dTTsGDkA5ZHKg;;;True;SuperAdmins;\r\naccount;admin@test.com;{PLAIN}toto;;;True;DomainAdmins;admin@test.com;test.com\r\naccount;user@test.com;{PLAIN}toto;;;True;SimpleUsers;user@test.com\r\naccount;user@test2.com;{PLAIN}toto;;;True;SimpleUsers;user@test2.com\r\n") + + def test_export_simpleusers(self): + response = self.__export_identities(grpfilter="SimpleUsers") + self.assertEqual( + response.content.strip(), + "account;user@test.com;{PLAIN}toto;;;True;SimpleUsers;user@test.com\r\naccount;user@test2.com;{PLAIN}toto;;;True;SimpleUsers;user@test2.com" + ) + + def test_export_superadmins(self): + response = self.__export_identities(grpfilter="SuperAdmins") + self.assertEqual( + response.content.strip(), + "account;admin;{CRYPT}dTTsGDkA5ZHKg;;;True;SuperAdmins;" + ) + + def test_export_domainadmins(self): + response = self.__export_identities(grpfilter="DomainAdmins") + self.assertEqual( + response.content.strip(), + "account;admin@test.com;{PLAIN}toto;;;True;DomainAdmins;admin@test.com;test.com" + ) diff --git a/modoboa/extensions/admin/tests/import_.py b/modoboa/extensions/admin/tests/import_.py new file mode 100644 index 000000000..186f3ff1d --- /dev/null +++ b/modoboa/extensions/admin/tests/import_.py @@ -0,0 +1,119 @@ +# coding: utf-8 +from django.core.urlresolvers import reverse +from django.core.files.base import ContentFile +from modoboa.core.models import User +from modoboa.lib.tests import ModoTestCase +from modoboa.extensions.admin.models import ( + Domain, Alias, DomainAlias +) +from modoboa.extensions.admin import factories + + +class ImportTestCase(ModoTestCase): + fixtures = ["initial_users.json"] + + def setUp(self): + super(ImportTestCase, self).setUp() + factories.populate_database() + + def test_domains_import(self): + f = ContentFile(b"""domain; domain1.com; 100; True +domain; domain2.com; 200; False +domainalias; domalias1.com; domain1.com; True +""", name="domains.csv") + self.clt.post( + reverse("modoboa.extensions.admin.views.import.import_domains"), { + "sourcefile": f + } + ) + admin = User.objects.get(username="admin") + dom = Domain.objects.get(name="domain1.com") + self.assertEqual(dom.quota, 100) + self.assertTrue(dom.enabled) + self.assertTrue(admin.is_owner(dom)) + domalias = DomainAlias.objects.get(name="domalias1.com") + self.assertEqual(domalias.target, dom) + self.assertTrue(dom.enabled) + self.assertTrue(admin.is_owner(domalias)) + dom = Domain.objects.get(name="domain2.com") + self.assertEqual(dom.quota, 200) + self.assertFalse(dom.enabled) + self.assertTrue(admin.is_owner(dom)) + + def test_identities_import(self): + f = ContentFile(b""" +account; user1@test.com; toto; User; One; True; SimpleUsers; user1@test.com +account; truc@test.com; toto; René; Truc; True; DomainAdmins; truc@test.com; test.com +alias; alias1@test.com; True; user1@test.com +forward; fwd1@test.com; True; user@extdomain.com +dlist; dlist@test.com; True; user1@test.com; user@extdomain.com +""", name="identities.csv") + self.clt.post( + reverse("modoboa.extensions.admin.views.import.import_identities"), + {"sourcefile": f, "crypt_password": True} + ) + admin = User.objects.get(username="admin") + u1 = User.objects.get(username="user1@test.com") + self.assertTrue(admin.is_owner(u1)) + self.assertEqual(u1.email, "user1@test.com") + self.assertEqual(u1.first_name, "User") + self.assertEqual(u1.last_name, "One") + self.assertTrue(u1.is_active) + self.assertEqual(u1.group, "SimpleUsers") + self.assertTrue(admin.is_owner(u1.mailbox_set.all()[0])) + self.assertEqual(u1.mailbox_set.all()[0].full_address, "user1@test.com") + self.assertTrue(self.clt.login(username="user1@test.com", password="toto")) + + da = User.objects.get(username="truc@test.com") + self.assertEqual(da.first_name, u"René") + self.assertEqual(da.group, "DomainAdmins") + self.assertEqual(da.mailbox_set.all()[0].full_address, "truc@test.com") + dom = Domain.objects.get(name="test.com") + self.assertIn(da, dom.admins) + u = User.objects.get(username="user@test.com") + self.assertTrue(da.can_access(u)) + + al = Alias.objects.get(address="alias1", domain__name="test.com") + self.assertIn(u1.mailbox_set.all()[0], al.mboxes.all()) + self.assertTrue(admin.is_owner(al)) + + fwd = Alias.objects.get(address="fwd1", domain__name="test.com") + self.assertIn("user@extdomain.com", fwd.extmboxes) + self.assertTrue(admin.is_owner(fwd)) + + dlist = Alias.objects.get(address="dlist", domain__name="test.com") + self.assertIn(u1.mailbox_set.all()[0], dlist.mboxes.all()) + self.assertIn("user@extdomain.com", dlist.extmboxes) + self.assertTrue(admin.is_owner(dlist)) + + def test_import_duplicate(self): + f = ContentFile(b""" +account; admin@test.com; toto; Admin; ; True; DomainAdmins; admin@test.com; test.com +account; truc@test.com; toto; René; Truc; True; DomainAdmins; truc@test.com; test.com +""", name="identities.csv") + self.clt.post( + reverse("modoboa.extensions.admin.views.import.import_identities"), + {"sourcefile": f, "crypt_password": True, + "continue_if_exists": True} + ) + admin = User.objects.get(username="admin") + u1 = User.objects.get(username="truc@test.com") + self.assertTrue(admin.is_owner(u1)) + + def test_import_superadmin(self): + """Check if a domain admin can import a superadmin + + Expected result: no + """ + self.clt.logout() + self.assertTrue(self.clt.login(username="admin@test.com", password="toto")) + f = ContentFile(b""" +account; sa@test.com; toto; Super; Admin; True; SuperAdmins; superadmin@test.com +""", name="identities.csv") + self.clt.post( + reverse("modoboa.extensions.admin.views.import.import_identities"), + {"sourcefile": f, "crypt_password": True, + "continue_if_exists": True} + ) + with self.assertRaises(User.DoesNotExist): + User.objects.get(username="sa@test.com")