Attachment 10296 Details for Bug 45205

[patch] Test sending mails to user.mailAlternativeAddress (see comment)

71_postfix_unionmap (text/plain), 6.22 KB, created by Tobias Wenzel on 2020-02-18 12:29 CET

(hide)

Description:

Filename:

MIME Type:

Creator: Tobias Wenzel

Created: 2020-02-18 12:29 CET

Size: 6.22 KB

patch

obsolete

>#!/usr/share/ucs-test/runner python
>## desc: Test unionmap
>## tags: [udm,apptest]
>## roles: [domaincontroller_master]
>## exposure: dangerous
>## packages:
>##   - univention-config
>##   - univention-directory-manager-tools
>##   - univention-mail-server
>
># pylint: disable=attribute-defined-outside-init
>
>from __future__ import print_function
>import time
>import os
>import dns.resolver
>import tempfile
>from essential.mail import send_mail, check_delivery, create_shared_mailfolder, imap_search_mail
>from essential.mail import get_dovecot_maildir
>from univention.testing.mail import MailSink, MailSinkGuard
>from univention.testing.network import NetworkRedirector
>import univention.testing.utils as utils
>import univention.testing.udm as udm_test
>import univention.testing.strings as uts
>import univention.testing.ucr as ucr_test
>
>TIMEOUT = 10
>
>class Bunch(object):
>	"""
>	>>> y = Bunch(foo=42, bar='TEST')
>	>>> print repr(y.foo), repr(y.bar)
>	42 'TEST'
>
>	>>> x = Bunch()
>	>>> x.a = 4
>	>>> print x.a
>	4
>	"""
>	def __init__(self, **kwds):
>		self.__dict__.update(kwds)
>
>	def __str__(self):
>		result = []
>		for key, value in self.__dict__.iteritems():
>			result.append('%s=%r' % (key, value))
>		return 'Bunch(' + ', '.join(result) + ')'
>
>	def __repr__(self):
>		return str(self)
>
>
>def random_user(mail_alternative_address=None):
>	if mail_alternative_address is None:
>		mail_alternative_address = '%s@%s' % (uts.random_string(), domain)
>	user = Bunch()
>	user.mailPrimaryAddress = '%s@%s' % (uts.random_string(), domain)
>	user.mailAlternativeAddress = mail_alternative_address
>	user.mailHomeServer = '%s.%s' % (ucr.get('hostname'), domain)
>	user.dn, user.username = udm.create_user(set={
>		'mailHomeServer': user.mailHomeServer,
>		'mailPrimaryAddress': user.mailPrimaryAddress,
>		'mailAlternativeAddress': user.mailAlternativeAddress,
>	})
>	return user
>
>
>def imap_delivered_shared_folder(folder_name, msgid, token, user):
>	fqdn = '%s.%s' % (ucr.get('hostname'), domain)
>	for _ in range(TIMEOUT):
>		try:
>			found = imap_search_mail(messageid=msgid, server=fqdn, imap_user=user.mailPrimaryAddress,
>									 imap_folder=folder_name, use_ssl=True)
>		except AssertionError as exc:
>			print(exc)
>			found = False
>		if found:
>			print('Found mail in shared folder sent to %s' % (folder_name,))
>			break
>		time.sleep(1)
>	if not found:
>		utils.fail('Mail sent with token = %r to %s un-expectedly' % (token, folder_name))
>
>
>if __name__ == '__main__':
>	with ucr_test.UCSTestConfigRegistry() as ucr:
>		with udm_test.UCSTestUDM() as udm:
>			domain = ucr.get('domainname').lower()
>			should_be_delivered = True
>
>			# Case 1a) A mail to a@example.com is only delivered to user B but not to user A.
>			# As expected: user b does receive the mail, user a doesn't receive the mail.
>			a_user = random_user()
>			b_user = random_user(mail_alternative_address=a_user.mailPrimaryAddress)
>			token = str(time.time())
>			send_mail(recipients=a_user.mailPrimaryAddress, msg=token, debuglevel=0)
>			check_delivery(token, b_user.mailPrimaryAddress, should_be_delivered)
>			# check_delivery(token, a_user.mailPrimaryAddress, should_be_delivered)
>
>			# Case 1b) a group's mail is identical with a users mA.
>			# -> All users receive a mail.
>			group_mail = '%s@%s' % (uts.random_name(), domain)
>			user_a = random_user(mail_alternative_address=group_mail)
>			user_b = random_user()
>			group_dn, group_name = udm.create_group(
>				set={
>					'mailAddress': group_mail,
>					'users': [user_a.dn, user_b.dn]
>				}
>			)
>			token = str(time.time())
>			send_mail(recipients=group_mail, msg=token, debuglevel=0)
>			check_delivery(token, user_a.mailPrimaryAddress, should_be_delivered)
>			check_delivery(token, user_b.mailPrimaryAddress, should_be_delivered)
>
>			# Case 1c: a mailing list's mail is identical with a users mA.
>			# -> All users receive a mail.
>			list_name = uts.random_name()
>			mailing_list_mail = '%s@%s' % (list_name, domain)
>			user_a = random_user(mail_alternative_address=mailing_list_mail)
>			user_b = random_user()
>			udm.create_object(
>				'mail/lists',
>				set={
>					'name': list_name,
>					'mailAddress': mailing_list_mail,
>					'members': [user_a.mailPrimaryAddress, user_b.mailPrimaryAddress],
>				}
>			)
>			token = str(time.time())
>			send_mail(recipients=mailing_list_mail, msg=token, debuglevel=0)
>			check_delivery(token, user_a.mailPrimaryAddress, should_be_delivered)
>			check_delivery(token, user_b.mailPrimaryAddress, should_be_delivered)
>
>			# Case 1d: A user has mail@shared_folder as mA address.
>			# As expected: Mails are delivered to the user, but not to the shared folder.
>			folder_name = uts.random_name()
>			shared_folder_mail = '%s@%s' % (folder_name, domain)
>			user = random_user(mail_alternative_address=shared_folder_mail)
>			token = str(time.time())
>			msgid = uts.random_name()
>			fqdn = '%s.%s' % (ucr.get('hostname'), domain)
>			folder_dn, folder_name, folder_mailaddress = create_shared_mailfolder(udm, fqdn, mailAddress=shared_folder_mail,
>														 user_permission=['"%s" "%s"' % ('anyone', 'all')])
>			path = get_dovecot_maildir(shared_folder_mail)
>			assert os.path.exists(path), 'Maildir %r for shared folder with mail address does not exist! '
>			send_mail(recipients=shared_folder_mail, msg=token, debuglevel=0, messageid=msgid)
>			check_delivery(token, user.mailPrimaryAddress, should_be_delivered)
>			imap_delivered_shared_folder(folder_name, msgid, token, user)
>
>			# Case 2: When using a mailing list that sends mails to a group (with mail address),
>			# no mail is delivered to the group members, at least because groups and distlists are different lookup tables.
>			# -> All users receive a mail.
>			group_members = []
>			group_mails = []
>			for i in range(2):
>				user = random_user()
>				group_members.append(user.dn)
>				group_mails.append(user.mailPrimaryAddress)
>			group_mail = '%s@%s' % (uts.random_string(), domain)
>			group_dn, group_name = udm.create_group(
>				set={
>					'mailAddress': group_mail,
>					'users': group_members
>				}
>			)
>			list_name = uts.random_name()
>			list_mail = '%s@%s' % (list_name, domain)
>			udm.create_object(
>				'mail/lists',
>				set={
>					'name': list_name,
>					'mailAddress': list_mail,
>					'members': group_mail,
>				}
>			)
>			token = str(time.time())
>			send_mail(recipients=list_mail, msg=token, debuglevel=0)
>			for mail in group_mails:
>				check_delivery(token, mail, should_be_delivered)
>
>
>
>
>
>
>

Actions: View | Diff

Attachments on bug 45205: 10296 | 10508 | 10509