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)