def test_channel_classic_recipients(self):
""" Posting a message on a classic channel should work like classic post """
self.test_channel.write({'alias_name': False})
self.test_channel.message_subscribe([self.user_employee.partner_id.id, self.test_partner.id])
self.test_channel.message_post(body="Test", message_type='comment', subtype='mt_comment')
sent_emails = self._mails
self.assertEqual(len(sent_emails), 2)
for email in sent_emails:
self.assertIn(
email['email_to'][0],
[formataddr((self.user_employee.name, self.user_employee.email)), formataddr((self.test_partner.name, self.test_partner.email))])
def test_message_process_email_author(self):
""" Incoming email: recognized author: email_from, author_id, added as follower """
record = self.format_and_process(MAIL_TEMPLATE,
email_from=formataddr(
(self.partner_1.name,
self.partner_1.email)))
self.assertEqual(record.message_ids[0].author_id, self.partner_1,
'message_process: recognized email -> author_id')
self.assertEqual(
record.message_ids[0].email_from,
formataddr((self.partner_1.name, self.partner_1.email)))
self.assertEqual(len(self._mails), 0,
'No notification / bounce should be sent')
def test_message_process_alias_followers_bounce(self):
""" Incoming email from unknown partner / not follower partner on a Followers only alias -> bounce """
self.alias.write({
'alias_contact':
'followers',
'alias_parent_model_id':
self.env['ir.model']._get('mail.test.simple').id,
'alias_parent_thread_id':
self.test_record.id,
})
# Test: unknown on followers alias -> bounce
record = self.format_and_process(
MAIL_TEMPLATE, to='[email protected], [email protected]')
self.assertEqual(len(record), 0,
'message_process: should have bounced')
self.assertEqual(
len(self._mails), 1,
'message_process: incoming email on Followers alias should send a bounce email'
)
# Test: partner on followers alias -> bounce
self._init_mock_build_email()
record = self.format_and_process(MAIL_TEMPLATE,
email_from=formataddr(
(self.partner_1.name,
self.partner_1.email)))
self.assertTrue(
len(record) == 0, 'message_process: should have bounced')
self.assertEqual(
len(self._mails), 1,
'message_process: incoming email on Followers alias should send a bounce email'
)
def test_message_process_alias_update(self):
""" Incoming email update discussion + notification email """
self.alias.write({'alias_force_thread_id': self.test_record.id})
self.test_record.message_subscribe(partner_ids=[self.partner_1.id])
record = self.format_and_process(
MAIL_TEMPLATE,
email_from='*****@*****.**',
msg_id=
'<*****@*****.**>',
to='*****@*****.**>',
subject='Re: cats')
# Test: no new group + new message
self.assertEqual(
len(record), 0,
'message_process: alias update should not create new records')
self.assertEqual(len(self.test_record.message_ids), 2)
# Test: sent emails: 1 (Sylvie copy of the incoming email)
self.assertEqual(
len(self._mails), 1,
'message_process: one email should have been generated')
self.assertEqual(
formataddr((self.partner_1.name, self.partner_1.email)),
self._mails[0].get('email_to')[0],
'message_process: email should be sent to Sylvie')
def _compute_email_formatted(self):
for partner in self:
if partner.email:
partner.email_formatted = tools.formataddr(
(partner.name or u"False", partner.email or u"False"))
else:
partner.email_formatted = ''
def _create_new_message(self,
channel_id,
status='pending_moderation',
author=None,
body='',
message_type="email"):
author = author if author else self.env.user.partner_id
message = self.env['mail.message'].create({
'model':
'mail.channel',
'res_id':
channel_id,
'message_type':
'email',
'body':
body,
'moderation_status':
status,
'author_id':
author.id,
'email_from':
formataddr((author.name, author.email)),
'subtype_id':
self.env['mail.message.subtype'].search([('name', '=',
'Discussions')]).id
})
return message
def test_message_process_model_res_id(self):
""" Incoming email with ref holding model / res_id but that does not match any message in the thread: must raise since OpenERP saas-3 """
self.assertRaises(
ValueError,
self.format_and_process,
MAIL_TEMPLATE,
email_from=formataddr((self.partner_1.name, self.partner_1.email)),
to='*****@*****.**',
subject='spam',
extra='In-Reply-To: <12321321-openerp-%d-mail.test.simple@%s>' %
(self.test_record.id, socket.gethostname()),
msg_id=
'<*****@*****.**>')
# when 6.1 messages are present, compat mode is available
# Swerp 10 update: compat mode has been removed and should not work anymore
self.fake_email.write({'message_id': False})
# Do: compat mode accepts partial-matching emails
self.assertRaises(
ValueError,
self.format_and_process,
MAIL_TEMPLATE,
email_from=formataddr((self.partner_1.name, self.partner_1.email)),
msg_id='<*****@*****.**>',
to='*****@*****.**>',
subject='spam',
extra='In-Reply-To: <12321321-openerp-%d-mail.test.simple@%s>' %
(self.test_record.id, socket.gethostname()))
# 3''. 6.1 compat mode should not work if hostname does not match!
# Swerp 10 update: compat mode has been removed and should not work anymore and does not depend from hostname
self.assertRaises(
ValueError,
self.format_and_process,
MAIL_TEMPLATE,
email_from=formataddr((self.partner_1.name, self.partner_1.email)),
msg_id='<*****@*****.**>',
to='*****@*****.**>',
subject='spam',
extra='In-Reply-To: <*****@*****.**>' %
self.test_record.id)
# Test created messages
self.assertEqual(len(self.test_record.message_ids), 1)
self.assertEqual(len(self.test_record.message_ids[0].child_ids), 0)
def encode_addr(addr):
name, email = addr
try:
return formataddr((name, email), 'ascii')
except UnicodeEncodeError:
_logger.warning(
_('Failed to encode the address %s\n'
'from mail header:\n%s') % (addr, header_text))
return ""
def test_message_process_alias_partner(self):
""" Incoming email from a known partner on a Partners alias -> ok (+ test on alias.user_id) """
self.alias.write({'alias_contact': 'partners'})
record = self.format_and_process(MAIL_TEMPLATE,
email_from=formataddr(
(self.partner_1.name,
self.partner_1.email)))
# Test: one group created by alias user
self.assertEqual(len(record), 1)
self.assertEqual(len(record.message_ids), 1)
def test_post_log(self):
new_note = self.test_record.sudo(self.user_employee)._message_log(
body='<p>Labrador</p>', )
self.assertEqual(new_note.subtype_id, self.env.ref('mail.mt_note'))
self.assertEqual(new_note.body, '<p>Labrador</p>')
self.assertEqual(new_note.author_id, self.user_employee.partner_id)
self.assertEqual(
new_note.email_from,
formataddr((self.user_employee.name, self.user_employee.email)))
self.assertEqual(new_note.needaction_partner_ids,
self.env['res.partner'])
def test_channel_blacklisted_recipients(self):
""" Posting a message on a channel should send one email to all recipients, except the blacklisted ones """
self.test_channel = self.env['mail.channel'].create({
'name': 'Test',
'description': 'Description',
'alias_name': 'test',
'public': 'public',
})
self.test_partner = self.env['res.partner'].create({
'name': 'Test Partner',
'email': '*****@*****.**',
})
self.blacklisted_partner = self.env['res.partner'].create({
'name': 'Blacklisted Partner',
'email': '*****@*****.**',
})
# Set Blacklist
self.env['mail.blacklist'].create({
'email': '*****@*****.**',
})
self.env['ir.config_parameter'].set_param('mail.catchall.domain', 'schlouby.fr')
self.test_channel.write({'email_send': True})
self._join_channel(self.test_channel, self.test_partner)
self.test_channel.message_post(body="Test", message_type='comment', subtype='mt_comment')
self.assertEqual(len(self._mails), 1, 'Number of mail incorrect. Should be equal to 1.')
for email in self._mails:
self.assertEqual(
set(email['email_to']),
set([formataddr((self.test_partner.name, self.test_partner.email))]),
'email_to incorrect. Should be equal to "%s"' % (
formataddr((self.test_partner.name, self.test_partner.email))))
def test_message_process_alias_followers(self):
""" Incoming email from a parent document follower on a Followers only alias -> ok """
self.alias.write({
'alias_contact':
'followers',
'alias_parent_model_id':
self.env['ir.model']._get('mail.test.simple').id,
'alias_parent_thread_id':
self.test_record.id,
})
self.test_record.message_subscribe(partner_ids=[self.partner_1.id])
record = self.format_and_process(MAIL_TEMPLATE,
email_from=formataddr(
(self.partner_1.name,
self.partner_1.email)))
# Test: one group created by Raoul (or Sylvie maybe, if we implement it)
self.assertEqual(len(record), 1)
def test_post_notify(self):
self.user_employee.write({'notification_type': 'inbox'})
new_notification = self.env['mail.thread'].message_notify(
subject='This should be a subject',
body='<p>You have received a notification</p>',
partner_ids=[(4, self.partner_1.id),
(4, self.user_employee.partner_id.id)],
)
self.assertEqual(new_notification.subtype_id,
self.env.ref('mail.mt_note'))
self.assertEqual(new_notification.body,
'<p>You have received a notification</p>')
self.assertEqual(new_notification.author_id, self.env.user.partner_id)
self.assertEqual(new_notification.email_from,
formataddr((self.env.user.name, self.env.user.email)))
self.assertEqual(new_notification.needaction_partner_ids,
self.partner_1 | self.user_employee.partner_id)
def test_channel_mailing_list_recipients(self):
""" Posting a message on a mailing list should send one email to all recipients """
self.env['ir.config_parameter'].set_param('mail.catchall.domain', 'schlouby.fr')
self.test_channel.write({'email_send': True})
# Subscribe an user without email. We shouldn't try to send email to them.
nomail = self.env['res.users'].create({
"login": "******",
"name": "No Mail",
"email": False,
"notification_type": "email",
})
self._join_channel(self.test_channel, self.user_employee.partner_id | self.test_partner | nomail.partner_id)
self.test_channel.message_post(body="Test", message_type='comment', subtype='mt_comment')
self.assertEqual(len(self._mails), 1)
for email in self._mails:
self.assertEqual(
set(email['email_to']),
set([formataddr((self.user_employee.name, self.user_employee.email)), formataddr((self.test_partner.name, self.test_partner.email))]))
def test_complex_mail_mail_send(self):
message = self.env['mail.message'].sudo().create({
'subject': 'Test',
'body': '<p>Test</p>',
'author_id': self.env.user.partner_id.id,
'email_from': self.env.user.partner_id.email,
'model': 'mail.test',
'res_id': self.umbrella.id,
})
mail = self.env['mail.mail'].sudo().create({
'body_html': '<p>Test</p>',
'mail_message_id': message.id,
'recipient_ids': [(4, pid) for pid in self.partners.ids],
})
mail_ids = mail.ids
with self.assertQueryCount(__system__=14, emp=21): # test_mail only: 14 - 21
self.env['mail.mail'].browse(mail_ids).send()
self.assertEqual(mail.body_html, '<p>Test</p>')
self.assertEqual(mail.reply_to, formataddr(('%s %s' % (self.env.user.company_id.name, self.umbrella.name), '*****@*****.**')))
def test_message_track_template(self):
""" Update some tracked fields linked to some template -> message with onchange """
self.record.write({
'mail_template':
self.env.ref('test_mail.mail_test_full_tracking_tpl').id
})
self.assertEqual(self.record.message_ids, self.env['mail.message'])
self.record.write({
'name': 'Test2',
'customer_id': self.user_admin.partner_id.id,
})
self.assertEqual(
len(self.record.message_ids), 2,
'should have 2 new messages: one for tracking, one for template')
# one new message containing the template linked to tracking
self.assertEqual(self.record.message_ids[0].subject, 'Test Template')
self.assertEqual(self.record.message_ids[0].body, '<p>Hello Test2</p>')
# one email send due to template
self.assertEqual(len(self._mails), 1)
self.assertEqual(
set(self._mails[0]['email_to']),
set([formataddr((self.user_admin.name, self.user_admin.email))]))
self.assertHtmlEqual(self._mails[0]['body'], '<p>Hello Test2</p>')
# one new message containing tracking; without subtype linked to tracking
self.assertEqual(self.record.message_ids[1].subtype_id,
self.env.ref('mail.mt_note'))
self.assertTracking(
self.record.message_ids[1],
[('customer_id', 'many2one', False, self.user_admin.partner_id
) # onchange tracked field
])
def assertEmails(self, partner_from, recipients, **values):
""" Tools method to ease the check of send emails """
expected_email_values = []
for partners in recipients:
if partner_from:
email_from = formataddr(
(partner_from.name, partner_from.email))
else:
email_from = values['email_from']
expected = {
'email_from':
email_from,
'email_to': [
formataddr((partner.name, partner.email))
for partner in partners
]
}
if 'reply_to' in values:
expected['reply_to'] = values['reply_to']
if 'subject' in values:
expected['subject'] = values['subject']
if 'attachments' in values:
expected['attachments'] = values['attachments']
if 'body' in values:
expected['body'] = values['body']
if 'body_content' in values:
expected['body_content'] = values['body_content']
if 'body_alt_content' in values:
expected['body_alternative_content'] = values[
'body_alt_content']
if 'references' in values:
expected['references'] = values['references']
if 'ref_content' in values:
expected['references_content'] = values['ref_content']
expected_email_values.append(expected)
self.assertEqual(len(self._mails), len(expected_email_values))
for expected in expected_email_values:
sent_mail = next(
(mail for mail in self._mails
if set(mail['email_to']) == set(expected['email_to'])), False)
self.assertTrue(
bool(sent_mail),
'Expected mail to %s not found' % expected['email_to'])
for val in [
'email_from', 'reply_to', 'subject', 'body', 'references',
'attachments'
]:
if val in expected:
self.assertEqual(
expected[val], sent_mail[val],
'Value for %s: expected %s, received %s' %
(val, expected[val], sent_mail[val]))
for val in [
'body_content', 'body_alternative', 'references_content'
]:
if val in expected:
self.assertIn(
expected[val], sent_mail[val[:-8]],
'Value for %s: %s does not contain %s' %
(val, sent_mail[val[:-8]], expected[val]))
def test_message_post(self):
email1 = '*****@*****.**'
email2 = '*****@*****.**'
self.channel_1._update_moderation_email([email1], 'ban')
self.channel_1._update_moderation_email([email2], 'allow')
msg_admin = self.channel_1.message_post(message_type='email', subtype='mt_comment', author_id=self.partner_admin.id)
msg_moderator = self.channel_1.message_post(message_type='comment', subtype='mt_comment', author_id=self.partner_employee.id)
msg_email1 = self.channel_1.message_post(message_type='comment', subtype='mt_comment', email_from=formataddr(("MyName", email1)))
msg_email2 = self.channel_1.message_post(message_type='email', subtype='mt_comment', email_from=email2)
msg_notif = self.channel_1.message_post()
messages = self.env['mail.message'].search([('model', '=', 'mail.channel'), ('res_id', '=', self.channel_1.id)])
pending_messages = messages.filtered(lambda m: m.moderation_status == 'pending_moderation')
accepted_messages = messages.filtered(lambda m: m.moderation_status == 'accepted')
self.assertFalse(msg_email1)
self.assertEqual(msg_admin, pending_messages)
self.assertEqual(accepted_messages, msg_moderator | msg_email2 | msg_notif)
self.assertFalse(msg_admin.channel_ids)
self.assertEqual(msg_email2.channel_ids, self.channel_1)
