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)
