def test_delete_user(self): self.reset_ldap_directory() user = core_factories.UserFactory( username=self.username, first_name="Test", last_name="LDAP", groups=("SimpleUsers",) ) user.delete() ldap_record = self.conn.search_s( force_str(self.dn), ldap.SCOPE_SUBTREE, force_str("(&(objectClass=inetOrgPerson))") ) password = ldap_record[0][1]["userPassword"][0].split(b"}")[1] self.assertTrue(password.startswith(b"#")) with self.assertRaises(ldap.INVALID_CREDENTIALS): lib.get_connection(self.config, self.dn, "toto") user = core_factories.UserFactory( username=self.username, first_name="Test", last_name="LDAP", groups=("SimpleUsers",) ) self.set_global_parameter( "ldap_sync_delete_remote_account", True, app="core") user.delete() self.assertFalse(lib.check_if_dn_exists(self.conn, self.dn))
def test_domain_import_with_mx_check(self, mock_getaddrinfo, mock_query): """Check domain import when MX check is enabled.""" reseller = core_factories.UserFactory( username="******", groups=("Resellers", )) self.client.force_login(reseller) self.set_global_parameter("valid_mxs", "192.0.2.1 2001:db8::1") self.set_global_parameter("domains_must_have_authorized_mx", True) mock_query.side_effect = utils.mock_dns_query_result mock_getaddrinfo.side_effect = utils.mock_ip_query_result f = ContentFile( b"domain; test3.com; 100; 1; True", name="domains.csv") resp = self.client.post( reverse("admin:domain_import"), { "sourcefile": f } ) self.assertContains(resp, "No authorized MX record found for domain") mock_getaddrinfo.side_effect = utils.mock_ip_query_result f = ContentFile( b"domain; domain1.com; 100; 1; True", name="domains.csv") resp = self.client.post( reverse("admin:domain_import"), { "sourcefile": f } ) self.assertTrue( Domain.objects.filter(name="domain1.com").exists())
def setUpTestData(cls): """Create test data.""" super(TestDataMixin, cls).setUpTestData() admin_factories.populate_database() cls.account = core_models.User.objects.get(username="******") cls.calendar = factories.UserCalendarFactory( mailbox=cls.account.mailbox) cls.admin_account = core_models.User.objects.get( username="******") cls.calendar2 = factories.UserCalendarFactory( mailbox=cls.admin_account.mailbox) cls.acr1 = factories.AccessRuleFactory( calendar=cls.calendar, mailbox=cls.admin_account.mailbox, read=True, write=True) cls.account2 = core_factories.UserFactory( username="******", groups=("SimpleUsers", ), ) admin_factories.MailboxFactory.create( address="user2", domain=cls.account.mailbox.domain, user=cls.account2) cls.domain = admin_models.Domain.objects.get(name="test.com") cls.scalendar = factories.SharedCalendarFactory(domain=cls.domain) cls.domain2 = admin_models.Domain.objects.get(name="test2.com") cls.scalendar2 = factories.SharedCalendarFactory(domain=cls.domain2)
def test_domain_import_with_mx_check(self, mock_gethostbyname, mock_query): """Check domain import when MX check is enabled.""" reseller = core_factories.UserFactory( username="******", groups=("Resellers", )) self.client.force_login(reseller) self.set_global_parameter("valid_mxs", "1.2.3.4") self.set_global_parameter("domains_must_have_authorized_mx", True) mock_query.return_value = [utils.FakeDNSAnswer("mail.ok.com")] mock_gethostbyname.return_value = "1.2.3.5" f = ContentFile( b"domain; domain1.com; 100; 1; True", name="domains.csv") resp = self.client.post( reverse("admin:domain_import"), { "sourcefile": f } ) self.assertContains(resp, "No authorized MX record found for domain") mock_gethostbyname.return_value = "1.2.3.4" f.seek(0) resp = self.client.post( reverse("admin:domain_import"), { "sourcefile": f } ) self.assertTrue( Domain.objects.filter(name="domain1.com").exists())
def test_create_domain_with_mx_check(self, mock_getaddrinfo, mock_query): """Check domain creation when MX check is activated.""" self.set_global_parameter("enable_admin_limits", False, app="limits") self.set_global_parameter("valid_mxs", "192.0.2.1 2001:db8::1") self.set_global_parameter("domains_must_have_authorized_mx", True) reseller = core_factories.UserFactory(username="******", groups=("Resellers", )) token = Token.objects.create(user=reseller) self.client.credentials(HTTP_AUTHORIZATION="Token " + token.key) url = reverse("api:domain-list") mock_query.side_effect = utils.mock_dns_query_result mock_getaddrinfo.side_effect = utils.mock_ip_query_result response = self.client.post(url, { "name": "no-mx.example.com", "quota": 0, "default_mailbox_quota": 10 }) self.assertEqual(response.status_code, 400) self.assertEqual(response.json()["name"][0], "No authorized MX record found for this domain") mock_getaddrinfo.side_effect = utils.mock_ip_query_result response = self.client.post(url, { "name": "test4.com", "quota": 0, "default_mailbox_quota": 10 }) self.assertEqual(response.status_code, 201)
def test_sync_domainadmin(self): self.reset_ldap_directory() core_factories.UserFactory(username=self.username, first_name="Test", last_name="LDAP", groups=("DomainAdmins", )) self.assertFalse(lib.check_if_dn_exists(self.conn, self.dn))
def test_create_domain_with_mx_check(self, mock_gethostbyname, mock_query): """Check domain creation when MX check is activated.""" self.set_global_parameter("enable_admin_limits", False, app="limits") self.set_global_parameter("valid_mxs", "1.2.3.4") self.set_global_parameter("domains_must_have_authorized_mx", True) reseller = core_factories.UserFactory(username="******", groups=("Resellers", )) token = Token.objects.create(user=reseller) self.client.credentials(HTTP_AUTHORIZATION='Token ' + token.key) url = reverse("api:domain-list") mock_query.return_value = [utils.FakeDNSAnswer("mail.ok.com")] mock_gethostbyname.return_value = "1.2.3.5" response = self.client.post(url, { "name": "test3.com", "quota": 0, "default_mailbox_quota": 10 }) self.assertEqual(response.status_code, 400) self.assertEqual(response.json()["name"][0], "No authorized MX record found for this domain") mock_gethostbyname.return_value = "1.2.3.4" response = self.client.post(url, { "name": "test3.com", "quota": 0, "default_mailbox_quota": 10 }) self.assertEqual(response.status_code, 201)
def test_create_and_check_mx(self, mock_gethostbyname, mock_query): """Check for authorized MX record.""" reseller = core_factories.UserFactory(username="******", groups=("Resellers", )) self.client.force_login(reseller) self.set_global_parameter("enable_admin_limits", False, app="limits") self.set_global_parameter("valid_mxs", "1.2.3.4") self.set_global_parameter("domains_must_have_authorized_mx", True) mock_query.return_value = [utils.FakeDNSAnswer("mail.ok.com")] mock_gethostbyname.return_value = "1.2.3.5" values = { "name": "pouet.com", "quota": 0, "default_mailbox_quota": 0, "create_dom_admin": True, "dom_admin_username": "******", "create_aliases": True, "type": "domain", "stepid": "step3", "with_mailbox": True } self.ajax_post(reverse("admin:domain_add"), values, 400) self.assertFalse(Domain.objects.filter(name=values["name"]).exists()) mock_gethostbyname.return_value = "1.2.3.4" self.ajax_post(reverse("admin:domain_add"), values)
def test_create_and_check_mx(self, mock_getaddrinfo, mock_query): """Check for authorized MX record.""" reseller = core_factories.UserFactory(username="******", groups=("Resellers", )) self.client.force_login(reseller) self.set_global_parameter("enable_admin_limits", False, app="limits") self.set_global_parameter("valid_mxs", "192.0.2.1 2001:db8::1") self.set_global_parameter("domains_must_have_authorized_mx", True) mock_query.side_effect = utils.mock_dns_query_result mock_getaddrinfo.side_effect = utils.mock_ip_query_result values = { "name": "no-mx.example.com", "quota": 0, "default_mailbox_quota": 0, "create_dom_admin": True, "dom_admin_username": "******", "create_aliases": True, "type": "domain", "stepid": "step3", "with_mailbox": True } self.ajax_post(reverse("admin:domain_add"), values, 400) self.assertFalse(Domain.objects.filter(name=values["name"]).exists()) values["name"] = "pouet.com" mock_getaddrinfo.side_effect = utils.mock_ip_query_result self.ajax_post(reverse("admin:domain_add"), values)
def setUpTestData(cls): """Create test data.""" super(LimitImportTestCase, cls).setUpTestData() admin_factories.populate_database() cls.reseller = core_factories.UserFactory(username="******", groups=("Resellers", )) cls.dadmin = core_models.User.objects.get(username="******") cls.domain = admin_models.Domain.objects.get(name="test.com")
def setUpTestData(cls): """Create test data.""" super(PermissionsTestCase, cls).setUpTestData() parameters = {} for name, tpl in limits_utils.get_user_limit_templates(): parameters["deflt_user_{0}_limit".format(name)] = 2 cls.localconfig.parameters.set_values(parameters, app="limits") cls.localconfig.save() factories.populate_database() cls.reseller = core_factories.UserFactory(username="******") cls.reseller.role = "Resellers" cls.user = User.objects.get(username="******")
def test_update_account_with_no_mailbox(self): """Try to disable an account.""" account = core_factories.UserFactory(username="******", groups=("Resellers", )) url = reverse("api:account-detail", args=[account.pk]) data = { "username": "******", "role": account.role, "is_active": False } response = self.client.put(url, data, format="json") self.assertEqual(response.status_code, 200)
def setUpTestData(cls): """Create test data.""" super(ResourcesAPITestCase, cls).setUpTestData() for name, tpl in utils.get_user_limit_templates(): cls.localconfig.parameters.set_value( "deflt_user_{0}_limit".format(name), 2) cls.localconfig.save() populate_database() cls.user = User.objects.get(username="******") cls.da_token = Token.objects.create(user=cls.user) cls.reseller = core_factories.UserFactory( username="******", groups=("Resellers", ), ) cls.r_token = Token.objects.create(user=cls.reseller)
def setUpTestData(cls): """Create test data.""" super(APIAdminLimitsTestCase, cls).setUpTestData() for name, tpl in utils.get_user_limit_templates(): parameters.save_admin("DEFLT_USER_{}_LIMIT".format(name.upper()), 2) populate_database() cls.user = User.objects.get(username="******") cls.da_token = Token.objects.create(user=cls.user) cls.reseller = core_factories.UserFactory( username="******", groups=("Resellers", ), ) cls.r_token = Token.objects.create(user=cls.reseller)
def test_delete_default_superadmin(self): """Delete default superadmin.""" sadmin2 = core_factories.UserFactory(username="******", is_superuser=True) sadmin = User.objects.get(username="******") self.client.force_login(sadmin2) self.ajax_post(reverse("admin:account_delete", args=[sadmin.pk]), {}) values = { "username": "******", "role": "DomainAdmins", "is_active": True, "email": "*****@*****.**" } account = User.objects.get(username="******") self.ajax_post(reverse("admin:account_change", args=[account.pk]), values)
def test_sync_user(self): self.reset_ldap_directory() user = core_factories.UserFactory(username=self.username, first_name="Test", last_name="LDAP", groups=("SimpleUsers", )) self.assertTrue(lib.check_if_dn_exists(self.conn, self.dn)) lib.get_connection(self.config, self.dn, "toto") user.last_name = "LDAP Modif" user.save() lib.get_connection(self.config, self.dn, "toto") res = self.conn.search_s(force_str(self.dn), ldap.SCOPE_SUBTREE, force_str("(&(objectClass=inetOrgPerson))")) self.assertIn(force_bytes(user.last_name), res[0][1]["sn"])
def setUpTestData(cls): """Create test data.""" from modoboa.lib import parameters from modoboa.limits import utils as limits_utils super(PermissionsTestCase, cls).setUpTestData() for name, tpl in limits_utils.get_user_limit_templates(): parameters.save_admin("DEFLT_USER_{0}_LIMIT".format(name.upper()), 2, app="limits") factories.populate_database() cls.reseller = core_factories.UserFactory(username="******") cls.reseller.role = "Resellers" cls.user = User.objects.get(username="******") cls.values = dict(username=cls.user.username, role="DomainAdmins", is_active=cls.user.is_active, email="*****@*****.**", quota_act=True)
def setUpTestData(cls): """Create some data.""" super(MXTestCase, cls).setUpTestData() cls.domain = factories.DomainFactory(name="modoboa.org") # should not exist cls.bad_domain = factories.DomainFactory(name="pouet.com") # Add domain admin with mailbox mb = factories.MailboxFactory(address="admin", domain=cls.bad_domain, user__username="******", user__groups=("DomainAdmins", )) cls.bad_domain.add_admin(mb.user) # Add domain admin with no mailbox admin = core_factories.UserFactory(username="******", groups=("DomainAdmins", )) cls.bad_domain.add_admin(admin) cls.localconfig.parameters.set_value("valid_mxs", "127.0.0.1") cls.localconfig.save() models.MXRecord.objects.all().delete()
def test_domain_admins_limit(self): """Try to exceed defined limit.""" domain = Domain.objects.get(name="test.com") limit = domain.domainobjectlimit_set.get(name="domain_admins") self.assertFalse(limit.is_exceeded()) user = User.objects.get(username="******") values = { "username": user.username, "role": user.role, "is_active": user.is_active, "email": user.email, "quota_act": True, "domains": "test2.com", "domains_1": "test.com" } self.ajax_post(reverse("admin:account_change", args=[user.id]), values) self.assertTrue(limit.is_exceeded()) user = core_factories.UserFactory(username="******", groups=("DomainAdmins", )) self.ajax_post(reverse("admin:account_change", args=[user.id]), values, 400)