initial commit 2

20 files changed, 7152 insertions, 0 deletions

diff --git a/addons/test_mail/tests/__init__.py b/addons/test_mail/tests/__init__.py
new file mode 100644
index 00000000..c2bbe943
--- /dev/null
+++ b/addons/test_mail/tests/__init__.py
@@ -0,0 +1,20 @@
+# -*- coding: utf-8 -*-
+
+from . import test_invite
+from . import test_ir_actions
+from . import test_mail_activity
+from . import test_mail_composer
+from . import test_mail_followers
+from . import test_mail_message
+from . import test_mail_mail
+from . import test_mail_channel
+from . import test_mail_channel_partner
+from . import test_mail_gateway
+from . import test_mail_thread_internals
+from . import test_mail_template
+from . import test_mail_tools
+from . import test_message_management
+from . import test_message_post
+from . import test_message_track
+from . import test_performance
+from . import test_ui
diff --git a/addons/test_mail/tests/common.py b/addons/test_mail/tests/common.py
new file mode 100644
index 00000000..c556a988
--- /dev/null
+++ b/addons/test_mail/tests/common.py
@@ -0,0 +1,71 @@
+# -*- coding: utf-8 -*-
+# Part of Odoo. See LICENSE file for full copyright and licensing details.
+
+from odoo.addons.mail.tests.common import MailCommon
+from odoo.tests.common import SavepointCase
+
+
+class TestMailCommon(MailCommon):
+    """ Main entry point for functional tests. """
+
+    @classmethod
+    def _create_channel_listener(cls):
+        cls.channel_listen = cls.env['mail.channel'].with_context(cls._test_context).create({'name': 'Listener'})
+
+    @classmethod
+    def _create_records_for_batch(cls, model, count):
+        # TDE note: to be cleaned in master
+        records = cls.env[model]
+        partners = cls.env['res.partner']
+        country_id = cls.env.ref('base.be').id
+
+        partners = cls.env['res.partner'].with_context(**cls._test_context).create([{
+            'name': 'Partner_%s' % (x),
+            'email': '_test_partner_%s@example.com' % (x),
+            'country_id': country_id,
+            'mobile': '047500%02d%02d' % (x, x)
+        } for x in range(count)])
+
+        records = cls.env[model].with_context(**cls._test_context).create([{
+            'name': 'Test_%s' % (x),
+            'customer_id': partners[x].id,
+        } for x in range(count)])
+
+        cls.records = cls._reset_mail_context(records)
+        cls.partners = partners
+        return cls.records, cls.partners
+
+
+class TestMailMultiCompanyCommon(MailCommon):
+
+    @classmethod
+    def setUpClass(cls):
+        super(TestMailMultiCompanyCommon, cls).setUpClass()
+        cls.company_2 = cls.env['res.company'].create({
+            'name': 'Second Test Company',
+        })
+
+
+class TestRecipients(SavepointCase):
+
+    @classmethod
+    def setUpClass(cls):
+        super(TestRecipients, cls).setUpClass()
+        Partner = cls.env['res.partner'].with_context({
+            'mail_create_nolog': True,
+            'mail_create_nosubscribe': True,
+            'mail_notrack': True,
+            'no_reset_password': True,
+        })
+        cls.partner_1 = Partner.create({
+            'name': 'Valid Lelitre',
+            'email': 'valid.lelitre@agrolait.com',
+            'country_id': cls.env.ref('base.be').id,
+            'mobile': '0456001122',
+        })
+        cls.partner_2 = Partner.create({
+            'name': 'Valid Poilvache',
+            'email': 'valid.other@gmail.com',
+            'country_id': cls.env.ref('base.be').id,
+            'mobile': '+32 456 22 11 00',
+        })
diff --git a/addons/test_mail/tests/test_invite.py b/addons/test_mail/tests/test_invite.py
new file mode 100644
index 00000000..c4e91a86
--- /dev/null
+++ b/addons/test_mail/tests/test_invite.py
@@ -0,0 +1,33 @@
+# -*- coding: utf-8 -*-
+# Part of Odoo. See LICENSE file for full copyright and licensing details.
+
+from odoo.addons.test_mail.tests.common import TestMailCommon
+from odoo.tools import mute_logger
+
+
+class TestInvite(TestMailCommon):
+
+    @mute_logger('odoo.addons.mail.models.mail_mail')
+    def test_invite_email(self):
+        test_record = self.env['mail.test.simple'].with_context(self._test_context).create({'name': 'Test', 'email_from': 'ignasse@example.com'})
+        test_partner = self.env['res.partner'].with_context(self._test_context).create({
+            'name': 'Valid Lelitre',
+            'email': 'valid.lelitre@agrolait.com'})
+
+        mail_invite = self.env['mail.wizard.invite'].with_context({
+            'default_res_model': 'mail.test.simple',
+            'default_res_id': test_record.id
+        }).with_user(self.user_employee).create({
+            'partner_ids': [(4, test_partner.id), (4, self.user_admin.partner_id.id)],
+            'send_mail': True})
+        with self.mock_mail_gateway():
+            mail_invite.add_followers()
+
+        # check added followers and that emails were sent
+        self.assertEqual(test_record.message_partner_ids,
+                         test_partner | self.user_admin.partner_id)
+        self.assertEqual(test_record.message_follower_ids.mapped('channel_id'),
+                         self.env['mail.channel'])
+        self.assertSentEmail(self.partner_employee, [test_partner])
+        self.assertSentEmail(self.partner_employee, [self.partner_admin])
+        self.assertEqual(len(self._mails), 2)
diff --git a/addons/test_mail/tests/test_ir_actions.py b/addons/test_mail/tests/test_ir_actions.py
new file mode 100644
index 00000000..d67124b2
--- /dev/null
+++ b/addons/test_mail/tests/test_ir_actions.py
@@ -0,0 +1,43 @@
+# -*- coding: utf-8 -*-
+# Part of Odoo. See LICENSE file for full copyright and licensing details.
+
+from odoo.addons.base.tests.test_ir_actions import TestServerActionsBase
+from odoo.addons.test_mail.tests.common import TestMailCommon
+
+
+class TestServerActionsEmail(TestMailCommon, TestServerActionsBase):
+
+    def test_action_email(self):
+        email_template = self._create_template('res.partner', {'partner_to': '%s' % self.test_partner.id})
+        self.action.write({'state': 'email', 'template_id': email_template.id})
+        self.action.with_context(self.context).run()
+        # check an email is waiting for sending
+        mail = self.env['mail.mail'].sudo().search([('subject', '=', 'About TestingPartner')])
+        self.assertEqual(len(mail), 1)
+        # check email content
+        self.assertEqual(mail.body, '<p>Hello TestingPartner</p>')
+
+    def test_action_followers(self):
+        self.test_partner.message_unsubscribe(self.test_partner.message_partner_ids.ids)
+        random_partner = self.env['res.partner'].create({'name': 'Thierry Wololo'})
+        self.action.write({
+            'state': 'followers',
+            'partner_ids': [(4, self.env.ref('base.partner_admin').id), (4, random_partner.id)],
+            'channel_ids': [(4, self.env.ref('mail.channel_all_employees').id)]
+        })
+        self.action.with_context(self.context).run()
+        self.assertEqual(self.test_partner.message_partner_ids, self.env.ref('base.partner_admin') | random_partner)
+        self.assertEqual(self.test_partner.message_channel_ids, self.env.ref('mail.channel_all_employees'))
+
+    def test_action_next_activity(self):
+        self.action.write({
+            'state': 'next_activity',
+            'activity_user_type': 'specific',
+            'activity_type_id': self.env.ref('mail.mail_activity_data_meeting').id,
+            'activity_summary': 'TestNew',
+        })
+        before_count = self.env['mail.activity'].search_count([])
+        run_res = self.action.with_context(self.context).run()
+        self.assertFalse(run_res, 'ir_actions_server: create next activity action correctly finished should return False')
+        self.assertEqual(self.env['mail.activity'].search_count([]), before_count + 1)
+        self.assertEqual(self.env['mail.activity'].search_count([('summary', '=', 'TestNew')]), 1)
diff --git a/addons/test_mail/tests/test_mail_activity.py b/addons/test_mail/tests/test_mail_activity.py
new file mode 100644
index 00000000..e6d4b003
--- /dev/null
+++ b/addons/test_mail/tests/test_mail_activity.py
@@ -0,0 +1,434 @@
+# -*- coding: utf-8 -*-
+# Part of Odoo. See LICENSE file for full copyright and licensing details.
+
+from datetime import date, datetime, timedelta
+from dateutil.relativedelta import relativedelta
+from unittest.mock import patch
+from unittest.mock import DEFAULT
+
+import pytz
+
+from odoo import fields, exceptions, tests
+from odoo.addons.test_mail.tests.common import TestMailCommon
+from odoo.addons.test_mail.models.test_mail_models import MailTestActivity
+from odoo.tools import mute_logger
+from odoo.tests.common import Form
+
+
+class TestActivityCommon(TestMailCommon):
+
+    @classmethod
+    def setUpClass(cls):
+        super(TestActivityCommon, cls).setUpClass()
+        cls.test_record = cls.env['mail.test.activity'].with_context(cls._test_context).create({'name': 'Test'})
+        # reset ctx
+        cls._reset_mail_context(cls.test_record)
+
+
+@tests.tagged('mail_activity')
+class TestActivityRights(TestActivityCommon):
+
+    @mute_logger('odoo.addons.mail.models.mail_mail')
+    def test_activity_security_user_access_other(self):
+        activity = self.test_record.with_user(self.user_employee).activity_schedule(
+            'test_mail.mail_act_test_todo',
+            user_id=self.user_admin.id)
+        self.assertTrue(activity.can_write)
+        activity.write({'user_id': self.user_employee.id})
+
+    @mute_logger('odoo.addons.mail.models.mail_mail')
+    def test_activity_security_user_access_own(self):
+        activity = self.test_record.with_user(self.user_employee).activity_schedule(
+            'test_mail.mail_act_test_todo')
+        self.assertTrue(activity.can_write)
+        activity.write({'user_id': self.user_admin.id})
+
+    @mute_logger('odoo.addons.mail.models.mail_mail')
+    def test_activity_security_user_noaccess_automated(self):
+        def _employee_crash(*args, **kwargs):
+            """ If employee is test employee, consider he has no access on document """
+            recordset = args[0]
+            if recordset.env.uid == self.user_employee.id:
+                raise exceptions.AccessError('Hop hop hop Ernest, please step back.')
+            return DEFAULT
+
+        with patch.object(MailTestActivity, 'check_access_rights', autospec=True, side_effect=_employee_crash):
+            activity = self.test_record.activity_schedule(
+                'test_mail.mail_act_test_todo',
+                user_id=self.user_employee.id)
+
+            activity2 = self.test_record.activity_schedule('test_mail.mail_act_test_todo')
+            activity2.write({'user_id': self.user_employee.id})
+
+    def test_activity_security_user_noaccess_manual(self):
+        def _employee_crash(*args, **kwargs):
+            """ If employee is test employee, consider he has no access on document """
+            recordset = args[0]
+            if recordset.env.uid == self.user_employee.id:
+                raise exceptions.AccessError('Hop hop hop Ernest, please step back.')
+            return DEFAULT
+
+        # cannot create activities for people that cannot access record
+        with patch.object(MailTestActivity, 'check_access_rights', autospec=True, side_effect=_employee_crash):
+            with self.assertRaises(exceptions.UserError):
+                activity = self.env['mail.activity'].create({
+                    'activity_type_id': self.env.ref('test_mail.mail_act_test_todo').id,
+                    'res_model_id': self.env.ref('test_mail.model_mail_test_activity').id,
+                    'res_id': self.test_record.id,
+                    'user_id': self.user_employee.id,
+                })
+
+        # cannot create activities if no access to the document
+        with patch.object(MailTestActivity, 'check_access_rights', autospec=True, side_effect=_employee_crash):
+            with self.assertRaises(exceptions.AccessError):
+                activity = self.test_record.with_user(self.user_employee).activity_schedule(
+                    'test_mail.mail_act_test_todo',
+                    user_id=self.user_admin.id)
+
+
+@tests.tagged('mail_activity')
+class TestActivityFlow(TestActivityCommon):
+
+    def test_activity_flow_employee(self):
+        with self.with_user('employee'):
+            test_record = self.env['mail.test.activity'].browse(self.test_record.id)
+            self.assertEqual(test_record.activity_ids, self.env['mail.activity'])
+
+            # employee record an activity and check the deadline
+            self.env['mail.activity'].create({
+                'summary': 'Test Activity',
+                'date_deadline': date.today() + relativedelta(days=1),
+                'activity_type_id': self.env.ref('mail.mail_activity_data_email').id,
+                'res_model_id': self.env['ir.model']._get(test_record._name).id,
+                'res_id': test_record.id,
+            })
+            self.assertEqual(test_record.activity_summary, 'Test Activity')
+            self.assertEqual(test_record.activity_state, 'planned')
+
+            test_record.activity_ids.write({'date_deadline': date.today() - relativedelta(days=1)})
+            test_record.invalidate_cache()  # TDE note: should not have to do it I think
+            self.assertEqual(test_record.activity_state, 'overdue')
+
+            test_record.activity_ids.write({'date_deadline': date.today()})
+            test_record.invalidate_cache()  # TDE note: should not have to do it I think
+            self.assertEqual(test_record.activity_state, 'today')
+
+            # activity is done
+            test_record.activity_ids.action_feedback(feedback='So much feedback')
+            self.assertEqual(test_record.activity_ids, self.env['mail.activity'])
+            self.assertEqual(test_record.message_ids[0].subtype_id, self.env.ref('mail.mt_activities'))
+
+    @mute_logger('odoo.addons.mail.models.mail_mail')
+    def test_activity_notify_other_user(self):
+        self.user_admin.notification_type = 'email'
+        rec = self.test_record.with_user(self.user_employee)
+        with self.assertSinglePostNotifications(
+                [{'partner': self.partner_admin, 'type': 'email'}],
+                message_info={'content': 'assigned you an activity', 'subtype': 'mail.mt_note', 'message_type': 'user_notification'}):
+            activity = rec.activity_schedule(
+                'test_mail.mail_act_test_todo',
+                user_id=self.user_admin.id)
+        self.assertEqual(activity.create_uid, self.user_employee)
+        self.assertEqual(activity.user_id, self.user_admin)
+
+    def test_activity_notify_same_user(self):
+        self.user_employee.notification_type = 'email'
+        rec = self.test_record.with_user(self.user_employee)
+        with self.assertNoNotifications():
+            activity = rec.activity_schedule(
+                'test_mail.mail_act_test_todo',
+                user_id=self.user_employee.id)
+        self.assertEqual(activity.create_uid, self.user_employee)
+        self.assertEqual(activity.user_id, self.user_employee)
+
+    @mute_logger('odoo.addons.mail.models.mail_mail')
+    def test_activity_dont_notify_no_user_change(self):
+        self.user_employee.notification_type = 'email'
+        activity = self.test_record.activity_schedule('test_mail.mail_act_test_todo', user_id=self.user_employee.id)
+        with self.assertNoNotifications():
+            activity.with_user(self.user_admin).write({'user_id': self.user_employee.id})
+        self.assertEqual(activity.user_id, self.user_employee)
+
+    @mute_logger('odoo.addons.mail.models.mail_mail')
+    def test_activity_summary_sync(self):
+        """ Test summary from type is copied on activities if set (currently only in form-based onchange) """
+        ActivityType = self.env['mail.activity.type']
+        email_activity_type = ActivityType.create({
+            'name': 'email',
+            'summary': 'Email Summary',
+        })
+        call_activity_type = ActivityType.create({'name': 'call'})
+        with Form(self.env['mail.activity'].with_context(default_res_model_id=self.env.ref('base.model_res_partner'))) as ActivityForm:
+            ActivityForm.res_model_id = self.env.ref('base.model_res_partner')
+
+            ActivityForm.activity_type_id = call_activity_type
+            # activity summary should be empty
+            self.assertEqual(ActivityForm.summary, False)
+
+            ActivityForm.activity_type_id = email_activity_type
+            # activity summary should be replaced with email's default summary
+            self.assertEqual(ActivityForm.summary, email_activity_type.summary)
+
+            ActivityForm.activity_type_id = call_activity_type
+            # activity summary remains unchanged from change of activity type as call activity doesn't have default summary
+            self.assertEqual(ActivityForm.summary, email_activity_type.summary)
+
+    def test_action_feedback_attachment(self):
+        Partner = self.env['res.partner']
+        Activity = self.env['mail.activity']
+        Attachment = self.env['ir.attachment']
+        Message = self.env['mail.message']
+
+        partner = self.env['res.partner'].create({
+            'name': 'Tester',
+        })
+
+        activity = Activity.create({
+            'summary': 'Test',
+            'activity_type_id': 1,
+            'res_model_id': self.env.ref('base.model_res_partner').id,
+            'res_id': partner.id,
+        })
+
+        attachments = Attachment
+        attachments += Attachment.create({
+            'name': 'test',
+            'res_name': 'test',
+            'res_model': 'mail.activity',
+            'res_id': activity.id,
+            'datas': 'test',
+        })
+        attachments += Attachment.create({
+            'name': 'test2',
+            'res_name': 'test',
+            'res_model': 'mail.activity',
+            'res_id': activity.id,
+            'datas': 'testtest',
+        })
+
+        # Checking if the attachment has been forwarded to the message
+        # when marking an activity as "Done"
+        activity.action_feedback()
+        activity_message = Message.search([], order='id desc', limit=1)
+        self.assertEqual(set(activity_message.attachment_ids.ids), set(attachments.ids))
+        for attachment in attachments:
+            self.assertEqual(attachment.res_id, activity_message.id)
+            self.assertEqual(attachment.res_model, activity_message._name)
+
+
+@tests.tagged('mail_activity')
+class TestActivityMixin(TestActivityCommon):
+
+    @mute_logger('odoo.addons.mail.models.mail_mail')
+    def test_activity_mixin(self):
+        self.user_employee.tz = self.user_admin.tz
+        with self.with_user('employee'):
+            self.test_record = self.env['mail.test.activity'].browse(self.test_record.id)
+            self.assertEqual(self.test_record.env.user, self.user_employee)
+
+            now_utc = datetime.now(pytz.UTC)
+            now_user = now_utc.astimezone(pytz.timezone(self.env.user.tz or 'UTC'))
+            today_user = now_user.date()
+
+            # Test various scheduling of activities
+            act1 = self.test_record.activity_schedule(
+                'test_mail.mail_act_test_todo',
+                today_user + relativedelta(days=1),
+                user_id=self.user_admin.id)
+            self.assertEqual(act1.automated, True)
+
+            act_type = self.env.ref('test_mail.mail_act_test_todo')
+            self.assertEqual(self.test_record.activity_summary, act_type.summary)
+            self.assertEqual(self.test_record.activity_state, 'planned')
+            self.assertEqual(self.test_record.activity_user_id, self.user_admin)
+
+            act2 = self.test_record.activity_schedule(
+                'test_mail.mail_act_test_meeting',
+                today_user + relativedelta(days=-1))
+            self.assertEqual(self.test_record.activity_state, 'overdue')
+            # `activity_user_id` is defined as `fields.Many2one('res.users', 'Responsible User', related='activity_ids.user_id')`
+            # it therefore relies on the natural order of `activity_ids`, according to which activity comes first.
+            # As we just created the activity, its not yet in the right order.
+            # We force it by invalidating it so it gets fetched from database, in the right order.
+            self.test_record.invalidate_cache(['activity_ids'])
+            self.assertEqual(self.test_record.activity_user_id, self.user_employee)
+
+            act3 = self.test_record.activity_schedule(
+                'test_mail.mail_act_test_todo',
+                today_user + relativedelta(days=3),
+                user_id=self.user_employee.id)
+            self.assertEqual(self.test_record.activity_state, 'overdue')
+            # `activity_user_id` is defined as `fields.Many2one('res.users', 'Responsible User', related='activity_ids.user_id')`
+            # it therefore relies on the natural order of `activity_ids`, according to which activity comes first.
+            # As we just created the activity, its not yet in the right order.
+            # We force it by invalidating it so it gets fetched from database, in the right order.
+            self.test_record.invalidate_cache(['activity_ids'])
+            self.assertEqual(self.test_record.activity_user_id, self.user_employee)
+
+            self.test_record.invalidate_cache(ids=self.test_record.ids)
+            self.assertEqual(self.test_record.activity_ids, act1 | act2 | act3)
+
+            # Perform todo activities for admin
+            self.test_record.activity_feedback(
+                ['test_mail.mail_act_test_todo'],
+                user_id=self.user_admin.id,
+                feedback='Test feedback',)
+            self.assertEqual(self.test_record.activity_ids, act2 | act3)
+
+            # Reschedule all activities, should update the record state
+            self.assertEqual(self.test_record.activity_state, 'overdue')
+            self.test_record.activity_reschedule(
+                ['test_mail.mail_act_test_meeting', 'test_mail.mail_act_test_todo'],
+                date_deadline=today_user + relativedelta(days=3)
+            )
+            self.assertEqual(self.test_record.activity_state, 'planned')
+
+            # Perform todo activities for remaining people
+            self.test_record.activity_feedback(
+                ['test_mail.mail_act_test_todo'],
+                feedback='Test feedback')
+
+            # Setting activities as done should delete them and post messages
+            self.assertEqual(self.test_record.activity_ids, act2)
+            self.assertEqual(len(self.test_record.message_ids), 2)
+            self.assertEqual(self.test_record.message_ids.mapped('subtype_id'), self.env.ref('mail.mt_activities'))
+
+            # Perform meeting activities
+            self.test_record.activity_unlink(['test_mail.mail_act_test_meeting'])
+
+            # Canceling activities should simply remove them
+            self.assertEqual(self.test_record.activity_ids, self.env['mail.activity'])
+            self.assertEqual(len(self.test_record.message_ids), 2)
+
+    @mute_logger('odoo.addons.mail.models.mail_mail')
+    def test_activity_mixin_archive(self):
+        rec = self.test_record.with_user(self.user_employee)
+        new_act = rec.activity_schedule(
+            'test_mail.mail_act_test_todo',
+            user_id=self.user_admin.id)
+        self.assertEqual(rec.activity_ids, new_act)
+        rec.toggle_active()
+        self.assertEqual(rec.active, False)
+        self.assertEqual(rec.activity_ids, self.env['mail.activity'])
+        rec.toggle_active()
+        self.assertEqual(rec.active, True)
+        self.assertEqual(rec.activity_ids, self.env['mail.activity'])
+
+    @mute_logger('odoo.addons.mail.models.mail_mail')
+    def test_activity_mixin_reschedule_user(self):
+        rec = self.test_record.with_user(self.user_employee)
+        rec.activity_schedule(
+            'test_mail.mail_act_test_todo',
+            user_id=self.user_admin.id)
+        self.assertEqual(rec.activity_ids[0].user_id, self.user_admin)
+
+        # reschedule its own should not alter other's activities
+        rec.activity_reschedule(
+            ['test_mail.mail_act_test_todo'],
+            user_id=self.user_employee.id,
+            new_user_id=self.user_employee.id)
+        self.assertEqual(rec.activity_ids[0].user_id, self.user_admin)
+
+        rec.activity_reschedule(
+            ['test_mail.mail_act_test_todo'],
+            user_id=self.user_admin.id,
+            new_user_id=self.user_employee.id)
+        self.assertEqual(rec.activity_ids[0].user_id, self.user_employee)
+
+    @mute_logger('odoo.addons.mail.models.mail_mail')
+    def test_my_activity_flow_employee(self):
+        Activity = self.env['mail.activity']
+        date_today = date.today()
+        activity_1 = Activity.create({
+            'activity_type_id': self.env.ref('test_mail.mail_act_test_todo').id,
+            'date_deadline': date_today,
+            'res_model_id': self.env.ref('test_mail.model_mail_test_activity').id,
+            'res_id': self.test_record.id,
+            'user_id': self.user_admin.id,
+        })
+        activity_2 = Activity.create({
+            'activity_type_id': self.env.ref('test_mail.mail_act_test_call').id,
+            'date_deadline': date_today + relativedelta(days=1),
+            'res_model_id': self.env.ref('test_mail.model_mail_test_activity').id,
+            'res_id': self.test_record.id,
+            'user_id': self.user_employee.id,
+        })
+
+        test_record_1 = self.env['mail.test.activity'].with_context(self._test_context).create({'name': 'Test 1'})
+        activity_3 = Activity.create({
+            'activity_type_id': self.env.ref('test_mail.mail_act_test_todo').id,
+            'date_deadline': date_today,
+            'res_model_id': self.env.ref('test_mail.model_mail_test_activity').id,
+            'res_id': test_record_1.id,
+            'user_id': self.user_employee.id,
+        })
+        with self.with_user('employee'):
+            record = self.env['mail.test.activity'].search([('my_activity_date_deadline', '=', date_today)])
+            self.assertEqual(test_record_1, record)
+
+class TestReadProgressBar(tests.TransactionCase):
+    """Test for read_progress_bar"""
+
+    def test_week_grouping(self):
+        """The labels associated to each record in read_progress_bar should match
+        the ones from read_group, even in edge cases like en_US locale on sundays
+        """
+        model = self.env['mail.test.activity'].with_context(lang='en_US')
+
+        # Don't mistake fields date and date_deadline:
+        # * date is just a random value
+        # * date_deadline defines activity_state
+        model.create({
+            'date': '2021-05-02',
+            'name': "Yesterday, all my troubles seemed so far away",
+        }).activity_schedule(
+            'test_mail.mail_act_test_todo',
+            summary="Make another test super asap (yesterday)",
+            date_deadline=fields.Date.context_today(model) - timedelta(days=7),
+        )
+        model.create({
+            'date': '2021-05-09',
+            'name': "Things we said today",
+        }).activity_schedule(
+            'test_mail.mail_act_test_todo',
+            summary="Make another test asap",
+            date_deadline=fields.Date.context_today(model),
+        )
+        model.create({
+            'date': '2021-05-16',
+            'name': "Tomorrow Never Knows",
+        }).activity_schedule(
+            'test_mail.mail_act_test_todo',
+            summary="Make a test tomorrow",
+            date_deadline=fields.Date.context_today(model) + timedelta(days=7),
+        )
+
+        domain = [('date', "!=", False)]
+        groupby = "date:week"
+        progress_bar = {
+            'field': 'activity_state',
+            'colors': {
+                "overdue": 'danger',
+                "today": 'warning',
+                "planned": 'success',
+            }
+        }
+
+        # call read_group to compute group names
+        groups = model.read_group(domain, fields=['date'], groupby=[groupby])
+        progressbars = model.read_progress_bar(domain, group_by=groupby, progress_bar=progress_bar)
+        self.assertEqual(len(groups), 3)
+        self.assertEqual(len(progressbars), 3)
+
+        # format the read_progress_bar result to get a dictionary under this
+        # format: {activity_state: group_name}; the original format
+        # (after read_progress_bar) is {group_name: {activity_state: count}}
+        pg_groups = {
+            next(state for state, count in data.items() if count): group_name
+            for group_name, data in progressbars.items()
+        }
+
+        self.assertEqual(groups[0][groupby], pg_groups["overdue"])
+        self.assertEqual(groups[1][groupby], pg_groups["today"])
+        self.assertEqual(groups[2][groupby], pg_groups["planned"])
+
diff --git a/addons/test_mail/tests/test_mail_channel.py b/addons/test_mail/tests/test_mail_channel.py
new file mode 100644
index 00000000..e3357027
--- /dev/null
+++ b/addons/test_mail/tests/test_mail_channel.py
@@ -0,0 +1,586 @@
+# -*- coding: utf-8 -*-
+# Part of Odoo. See LICENSE file for full copyright and licensing details.
+
+from odoo.tests import tagged, Form
+from odoo.addons.mail.tests.common import mail_new_test_user
+from odoo.addons.test_mail.tests.common import TestMailCommon
+from odoo.exceptions import AccessError, ValidationError, UserError
+from odoo.tools import mute_logger, formataddr
+
+
+@tagged('mail_channel')
+class TestChannelAccessRights(TestMailCommon):
+
+    @classmethod
+    def setUpClass(cls):
+        super(TestChannelAccessRights, cls).setUpClass()
+        Channel = cls.env['mail.channel'].with_context(cls._test_context)
+
+        cls.user_public = mail_new_test_user(cls.env, login='bert', groups='base.group_public', name='Bert Tartignole')
+        cls.user_portal = mail_new_test_user(cls.env, login='chell', groups='base.group_portal', name='Chell Gladys')
+
+        # Pigs: base group for tests
+        cls.group_pigs = Channel.create({
+            'name': 'Pigs',
+            'public': 'groups',
+            'group_public_id': cls.env.ref('base.group_user').id})
+        # Jobs: public group
+        cls.group_public = Channel.create({
+            'name': 'Jobs',
+            'description': 'NotFalse',
+            'public': 'public'})
+        # Private: private group
+        cls.group_private = Channel.create({
+            'name': 'Private',
+            'public': 'private'})
+
+    @mute_logger('odoo.addons.base.models.ir_model', 'odoo.models')
+    def test_access_rights_public(self):
+        # Read public group -> ok
+        self.group_public.with_user(self.user_public).read()
+
+        # Read Pigs -> ko, restricted to employees
+        with self.assertRaises(AccessError):
+            self.group_pigs.with_user(self.user_public).read()
+
+        # Read a private group when being a member: ok
+        self.group_private.write({'channel_partner_ids': [(4, self.user_public.partner_id.id)]})
+        self.group_private.with_user(self.user_public).read()
+
+        # Create group: ko, no access rights
+        with self.assertRaises(AccessError):
+            self.env['mail.channel'].with_user(self.user_public).create({'name': 'Test'})
+
+        # Update group: ko, no access rights
+        with self.assertRaises(AccessError):
+            self.group_public.with_user(self.user_public).write({'name': 'Broutouschnouk'})
+
+        # Unlink group: ko, no access rights
+        with self.assertRaises(AccessError):
+            self.group_public.with_user(self.user_public).unlink()
+
+    @mute_logger('odoo.addons.base.models.ir_model', 'odoo.models', 'odoo.models.unlink')
+    def test_access_rights_groups(self):
+        # Employee read employee-based group: ok
+        self.group_pigs.with_user(self.user_employee).read()
+
+        # Employee can create a group
+        self.env['mail.channel'].with_user(self.user_employee).create({'name': 'Test'})
+
+        # Employee update employee-based group: ok
+        self.group_pigs.with_user(self.user_employee).write({'name': 'modified'})
+
+        # Employee unlink employee-based group: ok
+        self.group_pigs.with_user(self.user_employee).unlink()
+
+        # Employee cannot read a private group
+        with self.assertRaises(AccessError):
+            self.group_private.with_user(self.user_employee).read()
+
+        # Employee cannot write on private
+        with self.assertRaises(AccessError):
+            self.group_private.with_user(self.user_employee).write({'name': 're-modified'})
+
+    @mute_logger('odoo.addons.base.models.ir_model', 'odoo.models')
+    def test_access_rights_followers_ko(self):
+        # self.group_private.name has been put in the cache during the setup as sudo
+        # It must therefore be removed from the cache in other to validate the fact user_portal can't read it.
+        self.group_private.invalidate_cache(['name'])
+        with self.assertRaises(AccessError):
+            self.group_private.with_user(self.user_portal).name
+
+    def test_access_rights_followers_portal(self):
+        # Do: Chell is added into Pigs members and browse it -> ok for messages, ko for partners (no read permission)
+        self.group_private.write({'channel_partner_ids': [(4, self.user_portal.partner_id.id)]})
+        chell_pigs = self.group_private.with_user(self.user_portal)
+        trigger_read = chell_pigs.name
+        for message in chell_pigs.message_ids:
+            trigger_read = message.subject
+
+        with self.assertRaises(AccessError):
+            chell_pigs.message_partner_ids
+
+        for partner in self.group_private.message_partner_ids:
+            if partner.id == self.user_portal.partner_id.id:
+                # Chell can read her own partner record
+                continue
+            with self.assertRaises(AccessError):
+                trigger_read = partner.with_user(self.user_portal).name
+
+
+@tagged('mail_channel')
+class TestChannelFeatures(TestMailCommon):
+
+    @classmethod
+    def setUpClass(cls):
+        super(TestChannelFeatures, cls).setUpClass()
+        cls.test_channel = cls.env['mail.channel'].with_context(cls._test_context).create({
+            'name': 'Test',
+            'description': 'Description',
+            'alias_name': 'test',
+            'public': 'public',
+        })
+        cls.test_partner = cls.env['res.partner'].with_context(cls._test_context).create({
+            'name': 'Test Partner',
+            'email': 'test@example.com',
+        })
+
+    def _join_channel(self, channel, partners):
+        for partner in partners:
+            channel.write({'channel_last_seen_partner_ids': [(0, 0, {'partner_id': partner.id})]})
+        channel.invalidate_cache()
+
+    def _leave_channel(self, channel, partners):
+        for partner in partners:
+            channel._action_unfollow(partner)
+
+    def test_channel_listeners(self):
+        self.assertEqual(self.test_channel.message_channel_ids, self.test_channel)
+        self.assertEqual(self.test_channel.message_partner_ids, self.env['res.partner'])
+        self.assertEqual(self.test_channel.channel_partner_ids, self.env['res.partner'])
+
+        self._join_channel(self.test_channel, self.test_partner)
+        self.assertEqual(self.test_channel.message_channel_ids, self.test_channel)
+        self.assertEqual(self.test_channel.message_partner_ids, self.env['res.partner'])
+        self.assertEqual(self.test_channel.channel_partner_ids, self.test_partner)
+
+        self._leave_channel(self.test_channel, self.test_partner)
+        self.assertEqual(self.test_channel.message_channel_ids, self.test_channel)
+        self.assertEqual(self.test_channel.message_partner_ids, self.env['res.partner'])
+        self.assertEqual(self.test_channel.channel_partner_ids, self.env['res.partner'])
+
+    def test_channel_post_nofollow(self):
+        self.test_channel.message_post(body='Test', message_type='comment', subtype_xmlid='mail.mt_comment')
+        self.assertEqual(self.test_channel.message_channel_ids, self.test_channel)
+        self.assertEqual(self.test_channel.message_partner_ids, self.env['res.partner'])
+
+    @mute_logger('odoo.addons.mail.models.mail_mail', 'odoo.models.unlink')
+    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})
+        self.user_employee.write({'notification_type': 'email'})
+
+        # Subscribe an user without email. We shouldn't try to send email to them.
+        nomail = self.env['res.users'].create({
+            "login": "nomail",
+            "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)
+        with self.mock_mail_gateway():
+            self.test_channel.message_post(body="Test", message_type='comment', subtype_xmlid='mail.mt_comment')
+        self.assertSentEmail(self.test_channel.env.user.partner_id, [self.partner_employee, self.test_partner])
+
+    @mute_logger('odoo.addons.mail.models.mail_mail', 'odoo.models.unlink')
+    def test_channel_chat_recipients(self):
+        """ Posting a message on a chat should not send emails """
+        self.env['ir.config_parameter'].set_param('mail.catchall.domain', 'schlouby.fr')
+        self.test_channel.write({'email_send': False})
+        self._join_channel(self.test_channel, self.user_employee.partner_id | self.test_partner)
+        with self.mock_mail_gateway():
+            self.test_channel.message_post(body="Test", message_type='comment', subtype_xmlid='mail.mt_comment')
+        self.assertNotSentEmail()
+        self.assertEqual(len(self._mails), 0)
+
+    @mute_logger('odoo.addons.mail.models.mail_mail', 'odoo.models.unlink')
+    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])
+        with self.mock_mail_gateway():
+            self.test_channel.message_post(body="Test", message_type='comment', subtype_xmlid='mail.mt_comment')
+        self.assertSentEmail(self.test_channel.env.user.partner_id, [self.test_partner])
+
+    def test_channel_creation(self):
+        """A user that create a private channel should be able to read it."""
+        channel_form = Form(self.env['mail.channel'].with_user(self.user_employee))
+        channel_form.name = 'Test private channel'
+        channel_form.public = 'private'
+        channel = channel_form.save()
+        self.assertEqual(channel.name, 'Test private channel', 'Must be able to read the created channel')
+
+    def test_channel_get(self):
+        current_user = self.env['res.users'].create({
+            "login": "adam",
+            "name": "Jonas",
+        })
+        current_user = current_user.with_user(current_user)
+        current_partner = current_user.partner_id
+        other_partner = self.test_partner
+
+        # `channel_get` should return a new channel the first time a partner is given
+        initial_channel_info = current_user.env['mail.channel'].channel_get(partners_to=other_partner.ids)
+        self.assertEqual(set(p['id'] for p in initial_channel_info['members']), {current_partner.id, other_partner.id})
+
+        # `channel_get` should return the existing channel every time the same partner is given
+        same_channel_info = current_user.env['mail.channel'].channel_get(partners_to=other_partner.ids)
+        self.assertEqual(same_channel_info['id'], initial_channel_info['id'])
+
+        # `channel_get` should return the existing channel when the current partner is given together with the other partner
+        together_channel_info = current_user.env['mail.channel'].channel_get(partners_to=(current_partner + other_partner).ids)
+        self.assertEqual(together_channel_info['id'], initial_channel_info['id'])
+
+        # `channel_get` should return a new channel the first time just the current partner is given,
+        # even if a channel containing the current partner together with other partners already exists
+        solo_channel_info = current_user.env['mail.channel'].channel_get(partners_to=current_partner.ids)
+        self.assertNotEqual(solo_channel_info['id'], initial_channel_info['id'])
+        self.assertEqual(set(p['id'] for p in solo_channel_info['members']), {current_partner.id})
+
+        # `channel_get` should return the existing channel every time the current partner is given
+        same_solo_channel_info = current_user.env['mail.channel'].channel_get(partners_to=current_partner.ids)
+        self.assertEqual(same_solo_channel_info['id'], solo_channel_info['id'])
+
+    def test_channel_seen(self):
+        """
+        In case of concurrent channel_seen RPC, ensure the oldest call has no effect.
+        """
+        self.test_channel.write({'channel_type': 'chat'})
+        self.test_channel.action_follow()
+        msg_1 = self._add_messages(self.test_channel, 'Body1', author=self.user_employee.partner_id,
+            channel_ids=[self.test_channel.id])
+        msg_2 = self._add_messages(self.test_channel, 'Body2', author=self.user_employee.partner_id,
+            channel_ids=[self.test_channel.id])
+        ChannelAsUser = self.test_channel.with_user(self.user_employee).browse(self.test_channel.id)
+
+        self.test_channel.channel_seen(msg_2.id)
+        self.assertEqual(
+            ChannelAsUser.channel_info()[0]['seen_partners_info'][0]['seen_message_id'],
+            msg_2.id,
+            "Last message id should have been updated"
+        )
+
+        self.test_channel.channel_seen(msg_1.id)
+        self.assertEqual(
+            ChannelAsUser.channel_info()[0]['seen_partners_info'][0]['seen_message_id'],
+            msg_2.id,
+            "Last message id should stay the same after mark channel as seen with an older message"
+        )
+
+    @mute_logger('odoo.models.unlink')
+    def test_channel_auto_unsubscribe_archived_or_deleted_users(self):
+        """Archiving / deleting a user should automatically unsubscribe related partner from private channels"""
+        test_channel_private = self.env['mail.channel'].with_context(self._test_context).create({
+            'name': 'Winden caves',
+            'description': 'Channel to travel through time',
+            'public': 'private',
+        })
+        test_channel_group = self.env['mail.channel'].with_context(self._test_context).create({
+            'name': 'Sic Mundus',
+            'public': 'groups',
+            'group_public_id': self.env.ref('base.group_user').id})
+
+        test_user = self.env['res.users'].create({
+            "login": "adam",
+            "name": "Jonas",
+        })
+        test_partner = test_user.partner_id
+        test_chat = self.env['mail.channel'].with_context(self._test_context).create({
+            'name': 'test',
+            'channel_type': 'chat',
+            'public': 'private',
+            'channel_partner_ids': [(4, self.user_employee.partner_id.id), (4, test_partner.id)],
+        })
+
+        self._join_channel(self.test_channel, self.user_employee.partner_id | test_partner)
+        self._join_channel(test_channel_private, self.user_employee.partner_id | test_partner)
+        self._join_channel(test_channel_group, self.user_employee.partner_id | test_partner)
+
+        # Unsubscribe archived user from the private channels, but not from public channels and not from chat
+        self.user_employee.active = False
+        self.assertEqual(test_channel_private.channel_partner_ids, test_partner)
+        self.assertEqual(test_channel_group.channel_partner_ids, test_partner)
+        self.assertEqual(self.test_channel.channel_partner_ids, self.user_employee.partner_id | test_partner)
+        self.assertEqual(test_chat.channel_partner_ids, self.user_employee.partner_id | test_partner)
+
+        # Unsubscribe deleted user from the private channels, but not from public channels and not from chat
+        test_user.unlink()
+        self.assertEqual(test_channel_private.channel_partner_ids, self.env['res.partner'])
+        self.assertEqual(test_channel_group.channel_partner_ids, self.env['res.partner'])
+        self.assertEqual(self.test_channel.channel_partner_ids, self.user_employee.partner_id | test_partner)
+        self.assertEqual(test_chat.channel_partner_ids, self.user_employee.partner_id | test_partner)
+
+    def test_channel_unfollow_should_also_unsubscribe_the_partner(self):
+        self.test_channel.message_subscribe(self.test_partner.ids)
+        self.test_channel._action_unfollow(self.test_partner)
+
+        self.assertFalse(self.test_channel.message_partner_ids)
+
+    def test_channel_unfollow_should_not_post_message_if_the_partner_has_been_removed(self):
+        '''
+        When a partner leaves a channel, the system will help post a message under
+        that partner's name in the channel to notify others if `email_sent` is set `False`.
+        The message should only be posted when the partner is still a member of the channel
+        before method `_action_unfollow()` is called.
+        If the partner has been removed earlier, no more messages will be posted
+        even if `_action_unfollow()` is called again.
+        '''
+        self.test_channel.write({'email_send': False})
+        self._join_channel(self.test_channel, self.test_partner)
+        self.test_channel.message_subscribe(self.partner_employee.ids)
+
+        # a message should be posted to notify others when a partner is about to leave
+        with self.assertSinglePostNotifications([{'partner': self.partner_employee, 'type': 'inbox'}], {
+            'message_type': 'notification',
+            'subtype': 'mail.mt_comment',
+        }):
+            self.test_channel._action_unfollow(self.test_partner)
+
+        # no more messages should be posted if the partner has been removed before.
+        with self.assertNoNotifications():
+            self.test_channel._action_unfollow(self.test_partner)
+
+    def test_multi_company_chat(self):
+        company_A = self.env['res.company'].create({'name': 'Company A'})
+        company_B = self.env['res.company'].create({'name': 'Company B'})
+        test_user_1 = self.env['res.users'].create({
+            'login': 'user1',
+            'name': 'My First New User',
+            'company_ids': [(6, 0, company_A.ids)],
+            'company_id': company_A.id
+        })
+        test_user_2 = self.env['res.users'].create({
+            'login': 'user2',
+            'name': 'My Second New User',
+            'company_ids': [(6, 0, company_B.ids)],
+            'company_id': company_B.id
+        })
+        initial_channel_info = self.env['mail.channel'].with_user(test_user_1).with_context(allowed_company_ids=company_A.ids).channel_get(test_user_2.partner_id.ids)
+        self.assertTrue(initial_channel_info, 'should be able to chat with multi company user')
+
+    def test_multi_company_message_post_notifications(self):
+        company_1 = self.company_admin
+        company_2 = self.env['res.company'].create({'name': 'Company 2'})
+
+        # Company 1 and notification_type == "inbox"
+        user_1 = self.user_employee
+
+        # Company 1 and notification_type == "email"
+        user_2 = self.user_admin
+        user_2.notification_type = 'email'
+
+        user_3 = mail_new_test_user(
+            self.env, login='user3', email='user3@example.com', groups='base.group_user',
+            company_id=company_2.id, company_ids=[(6, 0, company_2.ids)],
+            name='user3', notification_type='inbox')
+
+        user_4 = mail_new_test_user(
+            self.env, login='user4', email='user4@example.com', groups='base.group_user',
+            company_id=company_2.id, company_ids=[(6, 0, company_2.ids)],
+            name='user4', notification_type='email')
+
+        partner_without_user = self.env['res.partner'].create({
+            'name': 'Partner',
+            'email': 'partner_test_123@example.com',
+        })
+        mail_channel = self.env['mail.channel'].with_user(user_1).create({
+            'name': 'Channel',
+            'channel_partner_ids': [
+                (4, user_1.partner_id.id),
+                (4, user_2.partner_id.id),
+                (4, user_3.partner_id.id),
+                (4, user_4.partner_id.id),
+                (4, partner_without_user.id),
+            ],
+            'email_send': True,
+        })
+
+        mail_channel.invalidate_cache()
+        (user_1 | user_2 | user_3 | user_4).invalidate_cache()
+
+        with self.mock_mail_gateway():
+            mail_channel.with_user(user_1).with_company(company_1).message_post(
+                body='Test body message 1337',
+                channel_ids=mail_channel.ids,
+            )
+
+        self.assertSentEmail(user_1.partner_id, [user_2.partner_id])
+        self.assertSentEmail(user_1.partner_id, [user_4.partner_id])
+        self.assertEqual(len(self._mails), 3, 'Should have send only 3 emails to user 2, user 4 and the partner')
+
+        self.assertBusNotifications([(self.cr.dbname, 'mail.channel', mail_channel.id)])
+
+        # Should not create mail notifications for user 1 & 3
+        self.assertFalse(self.env['mail.notification'].search([('res_partner_id', '=', user_1.partner_id.id)]))
+        self.assertFalse(self.env['mail.notification'].search([('res_partner_id', '=', user_3.partner_id.id)]))
+
+        # Should create mail notifications for user 2 & 4
+        self.assertTrue(self.env['mail.notification'].search([('res_partner_id', '=', user_2.partner_id.id)]))
+        self.assertTrue(self.env['mail.notification'].search([('res_partner_id', '=', user_4.partner_id.id)]))
+
+        # Check that we did not send a "channel_seen" notifications
+        # for the users which receive the notifications by email
+        notification_seen_user_2 = self.env['bus.bus'].search([('create_uid', '=', user_2.id)])
+        self.assertFalse(notification_seen_user_2, 'Should not have sent a notification as user 2')
+        notification_seen_user_4 = self.env['bus.bus'].search([('create_uid', '=', user_4.id)])
+        self.assertFalse(notification_seen_user_4, 'Should not have sent a notification as user 4')
+
+
+@tagged('moderation', 'mail_channel')
+class TestChannelModeration(TestMailCommon):
+
+    @classmethod
+    def setUpClass(cls):
+        super(TestChannelModeration, cls).setUpClass()
+
+        cls.channel_1 = cls.env['mail.channel'].create({
+            'name': 'Moderation_1',
+            'email_send': True,
+            'moderation': True,
+            'channel_partner_ids': [(4, cls.partner_employee.id)],
+            'moderator_ids': [(4, cls.user_employee.id)],
+        })
+
+        # ensure initial data
+        cls.user_employee_2 = mail_new_test_user(
+            cls.env, login='employee2', groups='base.group_user', company_id=cls.company_admin.id,
+            name='Enguerrand Employee2', notification_type='inbox', signature='--\nEnguerrand'
+        )
+        cls.partner_employee_2 = cls.user_employee_2.partner_id
+
+        cls.user_portal = cls._create_portal_user()
+
+    def test_moderator_consistency(self):
+        # moderators should be channel members
+        with self.assertRaises(ValidationError):
+            self.channel_1.write({'moderator_ids': [(4, self.user_admin.id)]})
+
+        # member -> moderator or
+        self.channel_1.write({'channel_partner_ids': [(4, self.partner_admin.id)]})
+        self.channel_1.write({'moderator_ids': [(4, self.user_admin.id)]})
+
+        # member -> moderator ko if no email
+        self.channel_1.write({'moderator_ids': [(3, self.partner_admin.id)]})
+        self.user_admin.write({'email': False})
+        with self.assertRaises(ValidationError):
+            self.channel_1.write({'moderator_ids': [(4, self.user_admin.id)]})
+
+    def test_moderation_consistency(self):
+        # moderation enabled channels are restricted to mailing lists
+        with self.assertRaises(ValidationError):
+            self.channel_1.write({'email_send': False})
+
+        # moderation enabled channels should always have moderators
+        with self.assertRaises(ValidationError):
+            self.channel_1.write({'moderator_ids': [(5, 0)]})
+
+    def test_moderation_count(self):
+        self.assertEqual(self.channel_1.moderation_count, 0)
+        self.channel_1.write({'moderation_ids': [
+            (0, 0, {'email': 'test0@example.com', 'status': 'allow'}),
+            (0, 0, {'email': 'test1@example.com', 'status': 'ban'})
+        ]})
+        self.assertEqual(self.channel_1.moderation_count, 2)
+
+    @mute_logger('odoo.addons.mail.models.mail_channel', 'odoo.models.unlink')
+    def test_send_guidelines(self):
+        self.channel_1.write({'channel_partner_ids': [(4, self.partner_portal.id), (4, self.partner_admin.id)]})
+        self.channel_1._update_moderation_email([self.partner_admin.email], 'ban')
+        with self.mock_mail_gateway():
+            self.channel_1.with_user(self.user_employee).send_guidelines()
+        for mail in self._new_mails:
+            self.assertEqual(mail.author_id, self.partner_employee)
+            self.assertEqual(mail.subject, 'Guidelines of channel %s' % self.channel_1.name)
+            self.assertEqual(mail.state, 'outgoing')
+            self.assertEqual(mail.email_from, self.user_employee.company_id.catchall_formatted)
+        self.assertEqual(self._new_mails.mapped('recipient_ids'), self.partner_employee | self.partner_portal)
+
+    def test_send_guidelines_crash(self):
+        self.channel_1.write({
+            'channel_partner_ids': [(4, self.partner_admin.id)],
+            'moderator_ids': [(4, self.user_admin.id), (3, self.user_employee.id)]
+        })
+        with self.assertRaises(UserError):
+            self.channel_1.with_user(self.user_employee).send_guidelines()
+
+    def test_update_moderation_email(self):
+        self.channel_1.write({'moderation_ids': [
+            (0, 0, {'email': 'test0@example.com', 'status': 'allow'}),
+            (0, 0, {'email': 'test1@example.com', 'status': 'ban'})
+        ]})
+        self.channel_1._update_moderation_email(['test0@example.com', 'test3@example.com'], 'ban')
+        self.assertEqual(len(self.channel_1.moderation_ids), 3)
+        self.assertTrue(all(status == 'ban' for status in self.channel_1.moderation_ids.mapped('status')))
+
+    def test_moderation_reset(self):
+        self.channel_2 = self.env['mail.channel'].create({
+            'name': 'Moderation_1',
+            'email_send': True,
+            'moderation': True,
+            'channel_partner_ids': [(4, self.partner_employee.id)],
+            'moderator_ids': [(4, self.user_employee.id)],
+        })
+
+        self.msg_c1_1 = self._add_messages(self.channel_1, 'Body11', author=self.partner_admin, moderation_status='accepted')
+        self.msg_c1_2 = self._add_messages(self.channel_1, 'Body12', author=self.partner_admin, moderation_status='pending_moderation')
+        self.msg_c2_1 = self._add_messages(self.channel_2, 'Body21', author=self.partner_admin, moderation_status='pending_moderation')
+
+        self.assertEqual(self.env['mail.message'].search_count([
+            ('moderation_status', '=', 'pending_moderation'),
+            ('model', '=', 'mail.channel'), ('res_id', '=', self.channel_1.id)
+        ]), 1)
+        self.channel_1.write({'moderation': False})
+        self.assertEqual(self.env['mail.message'].search_count([
+            ('moderation_status', '=', 'pending_moderation'),
+            ('model', '=', 'mail.channel'), ('res_id', '=', self.channel_1.id)
+        ]), 0)
+        self.assertEqual(self.env['mail.message'].search_count([
+            ('moderation_status', '=', 'pending_moderation'),
+            ('model', '=', 'mail.channel'), ('res_id', '=', self.channel_2.id)
+        ]), 1)
+        self.channel_2.write({'moderation': False})
+        self.assertEqual(self.env['mail.message'].search_count([
+            ('moderation_status', '=', 'pending_moderation'),
+            ('model', '=', 'mail.channel'), ('res_id', '=', self.channel_2.id)
+        ]), 0)
+
+    @mute_logger('odoo.models.unlink')
+    def test_message_post(self):
+        email1 = 'test0@example.com'
+        email2 = 'test1@example.com'
+
+        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_xmlid='mail.mt_comment', author_id=self.partner_admin.id)
+        msg_moderator = self.channel_1.message_post(message_type='comment', subtype_xmlid='mail.mt_comment', author_id=self.partner_employee.id)
+        msg_email1 = self.channel_1.message_post(message_type='comment', subtype_xmlid='mail.mt_comment', email_from=formataddr(("MyName", email1)))
+        msg_email2 = self.channel_1.message_post(message_type='email', subtype_xmlid='mail.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)
+
+    def test_user_is_moderator(self):
+        self.assertTrue(self.user_employee.is_moderator)
+        self.assertFalse(self.user_employee_2.is_moderator)
+        self.channel_1.write({
+            'channel_partner_ids': [(4, self.partner_employee_2.id)],
+            'moderator_ids': [(4, self.user_employee_2.id)],
+        })
+        self.assertTrue(self.user_employee_2.is_moderator)
+
+    def test_user_moderation_counter(self):
+        self._add_messages(self.channel_1, 'B', moderation_status='pending_moderation', author=self.partner_employee_2)
+        self._add_messages(self.channel_1, 'B', moderation_status='accepted', author=self.partner_employee_2)
+        self._add_messages(self.channel_1, 'B', moderation_status='accepted', author=self.partner_employee)
+        self._add_messages(self.channel_1, 'B', moderation_status='pending_moderation', author=self.partner_employee)
+        self._add_messages(self.channel_1, 'B', moderation_status='accepted', author=self.partner_employee)
+
+        self.assertEqual(self.user_employee.moderation_counter, 2)
+        self.assertEqual(self.user_employee_2.moderation_counter, 0)
+
+        self.channel_1.write({
+            'channel_partner_ids': [(4, self.partner_employee_2.id)],
+            'moderator_ids': [(4, self.user_employee_2.id)]
+        })
+        self.assertEqual(self.user_employee.moderation_counter, 2)
+        self.assertEqual(self.user_employee_2.moderation_counter, 0)
diff --git a/addons/test_mail/tests/test_mail_channel_partner.py b/addons/test_mail/tests/test_mail_channel_partner.py
new file mode 100644
index 00000000..93dd7072
--- /dev/null
+++ b/addons/test_mail/tests/test_mail_channel_partner.py
@@ -0,0 +1,214 @@
+# -*- coding: utf-8 -*-
+# Part of Odoo. See LICENSE file for full copyright and licensing details.
+
+
+from odoo.tests.common import SavepointCase
+from odoo.exceptions import AccessError, UserError
+
+
+class TestMailSecurity(SavepointCase):
+    @classmethod
+    def setUpClass(cls):
+        super().setUpClass()
+        cls.secret_group = cls.env['res.groups'].create({
+            'name': 'secret group',
+        })
+        cls.user_1 = cls.env['res.users'].create({
+            'name': 'User 1',
+            'login': 'user_1',
+            'email': '---',
+            'groups_id': [(6, 0, [cls.secret_group.id, cls.env.ref('base.group_user').id])],
+        })
+        cls.user_2 = cls.env['res.users'].create({
+            'name': 'User 2',
+            'login': 'user_2',
+            'email': '---',
+            'groups_id': [(6, 0, [cls.secret_group.id, cls.env.ref('base.group_user').id])],
+        })
+        cls.user_3 = cls.env['res.users'].create({
+            'name': 'User 3',
+            'login': 'user_3',
+            'email': '---',
+        })
+
+        cls.private_channel_1 = cls.env['mail.channel'].create({
+            'name': 'Secret channel',
+            'public': 'private',
+            'channel_type': 'channel',
+        })
+        cls.group_channel_1 = cls.env['mail.channel'].create({
+            'name': 'Group channel',
+            'public': 'groups',
+            'channel_type': 'channel',
+            'group_public_id': cls.secret_group.id,
+        })
+        cls.public_channel_1 = cls.env['mail.channel'].create({
+            'name': 'Public channel of user 1',
+            'public': 'public',
+            'channel_type': 'channel',
+        })
+        cls.private_channel_1.channel_last_seen_partner_ids.unlink()
+        cls.group_channel_1.channel_last_seen_partner_ids.unlink()
+        cls.public_channel_1.channel_last_seen_partner_ids.unlink()
+
+    ###########################
+    # PRIVATE CHANNEL & BASIC #
+    ###########################
+
+    def test_channel_acls_01(self):
+        """Test access on private channel."""
+        res = self.env['mail.channel.partner'].search([('channel_id', '=', self.private_channel_1.id)])
+        self.assertFalse(res)
+
+        # User 1 can join private channel with SUDO
+        self.private_channel_1.with_user(self.user_1).sudo().action_follow()
+        res = self.env['mail.channel.partner'].search([('channel_id', '=', self.private_channel_1.id)])
+        self.assertEqual(res.partner_id, self.user_1.partner_id)
+
+        # User 2 can not join private channel
+        with self.assertRaises(AccessError):
+            self.private_channel_1.with_user(self.user_2).action_follow()
+
+        # But user 2 can join public channel
+        self.public_channel_1.with_user(self.user_2).action_follow()
+        res = self.env['mail.channel.partner'].search([('channel_id', '=', self.public_channel_1.id)])
+        self.assertEqual(res.partner_id, self.user_2.partner_id)
+
+        # User 2 can not create a `mail.channel.partner` to join the private channel
+        with self.assertRaises(AccessError):
+            self.env['mail.channel.partner'].with_user(self.user_2).create({
+                'partner_id': self.user_2.partner_id.id,
+                'channel_id': self.private_channel_1.id,
+            })
+
+        # User 2 can not write on `mail.channel.partner` to join the private channel
+        channel_partner = self.env['mail.channel.partner'].with_user(self.user_2).search([('partner_id', '=', self.user_2.partner_id.id)])[0]
+        with self.assertRaises(AccessError):
+            channel_partner.channel_id = self.private_channel_1.id
+        with self.assertRaises(AccessError):
+            channel_partner.write({'channel_id': self.private_channel_1.id})
+
+        # But with SUDO, User 2 can
+        channel_partner.sudo().channel_id = self.private_channel_1.id
+
+        # User 2 can not write on the `partner_id` of `mail.channel.partner`
+        # of an other partner to join a private channel
+        channel_partner_1 = self.env['mail.channel.partner'].search([('channel_id', '=', self.private_channel_1.id), ('partner_id', '=', self.user_1.partner_id.id)])
+        with self.assertRaises(AccessError):
+            channel_partner_1.with_user(self.user_2).partner_id = self.user_2.partner_id
+        self.assertEqual(channel_partner_1.partner_id, self.user_1.partner_id)
+
+        # but with SUDO he can...
+        channel_partner_1.with_user(self.user_2).sudo().partner_id = self.user_2.partner_id
+        self.assertEqual(channel_partner_1.partner_id, self.user_2.partner_id)
+
+    def test_channel_acls_03(self):
+        """Test invitation in private channel part 1 (invite using crud methods)."""
+        self.private_channel_1.with_user(self.user_1).sudo().action_follow()
+        channel_partners = self.env['mail.channel.partner'].search([('channel_id', '=', self.private_channel_1.id)])
+        self.assertEqual(len(channel_partners), 1)
+
+        # User 2 is not in the private channel, he can not invite user 3
+        with self.assertRaises(AccessError):
+            self.env['mail.channel.partner'].with_user(self.user_2).create({
+                'partner_id': self.user_3.partner_id.id,
+                'channel_id': self.private_channel_1.id,
+            })
+
+        # User 1 is in the private channel, he can invite other users
+        self.env['mail.channel.partner'].with_user(self.user_1).create({
+            'partner_id': self.user_3.partner_id.id,
+            'channel_id': self.private_channel_1.id,
+        })
+        channel_partners = self.env['mail.channel.partner'].search([('channel_id', '=', self.private_channel_1.id)])
+        self.assertEqual(channel_partners.mapped('partner_id'), self.user_1.partner_id | self.user_3.partner_id)
+
+        # But User 3 can not write on the `mail.channel.partner` of other user
+        channel_partner_1 = self.env['mail.channel.partner'].search([('channel_id', '=', self.private_channel_1.id), ('partner_id', '=', self.user_1.partner_id.id)])
+        channel_partner_3 = self.env['mail.channel.partner'].search([('channel_id', '=', self.private_channel_1.id), ('partner_id', '=', self.user_3.partner_id.id)])
+        channel_partner_3.with_user(self.user_3).custom_channel_name = 'Test'
+        with self.assertRaises(AccessError):
+            channel_partner_1.with_user(self.user_2).custom_channel_name = 'Blabla'
+        self.assertNotEqual(channel_partner_1.custom_channel_name, 'Blabla')
+
+    def test_channel_acls_04(self):
+        """Test invitation in private channel part 2 (use `invite` action)."""
+        self.private_channel_1.with_user(self.user_1).sudo().action_follow()
+        channel_partners = self.env['mail.channel.partner'].search([('channel_id', '=', self.private_channel_1.id)])
+        self.assertEqual(channel_partners.mapped('partner_id'), self.user_1.partner_id)
+
+        # User 2 is not in the channel, he can not invite user 3
+        with self.assertRaises(AccessError):
+            self.private_channel_1.with_user(self.user_2).channel_invite([self.user_3.partner_id.id])
+        channel_partners = self.env['mail.channel.partner'].search([('channel_id', '=', self.private_channel_1.id)])
+        self.assertEqual(channel_partners.mapped('partner_id'), self.user_1.partner_id)
+
+        # User 1 is in the channel, he can not invite user 3
+        self.private_channel_1.with_user(self.user_1).channel_invite([self.user_3.partner_id.id])
+        channel_partners = self.env['mail.channel.partner'].search([('channel_id', '=', self.private_channel_1.id)])
+        self.assertEqual(channel_partners.mapped('partner_id'), self.user_1.partner_id | self.user_3.partner_id)
+
+    def test_channel_acls_05(self):
+        """Test kick/leave channel."""
+        self.private_channel_1.with_user(self.user_1).sudo().action_follow()
+        self.private_channel_1.with_user(self.user_3).sudo().action_follow()
+        channel_partners = self.env['mail.channel.partner'].search([('channel_id', '=', self.private_channel_1.id)])
+        self.assertEqual(len(channel_partners), 2)
+
+        # User 2 is not in the channel, he can not kick user 1
+        with self.assertRaises(AccessError):
+            channel_partners.with_user(self.user_2).unlink()
+
+        # User 3 is in the channel, he can kick user 1
+        channel_partners.with_user(self.user_3).unlink()
+
+    #################
+    # GROUP CHANNEL #
+    #################
+    def test_channel_acls_06(self):
+        """Test basics on group channel."""
+        channel_partners = self.env['mail.channel.partner'].search([('channel_id', '=', self.group_channel_1.id)])
+        self.assertFalse(channel_partners)
+
+        # user 1 is in the group, he can join the channel
+        self.group_channel_1.with_user(self.user_1).action_follow()
+        channel_partners = self.env['mail.channel.partner'].search([('channel_id', '=', self.group_channel_1.id)])
+        self.assertEqual(channel_partners.mapped('partner_id'), self.user_1.partner_id)
+
+        # user 3 is not in the group, he can not join
+        with self.assertRaises(AccessError):
+            self.group_channel_1.with_user(self.user_3).action_follow()
+
+        channel_partners = self.env['mail.channel.partner'].search([('channel_id', '=', self.group_channel_1.id)])
+        with self.assertRaises(AccessError):
+            channel_partners.with_user(self.user_3).partner_id = self.user_3.partner_id
+
+        channel_partners = self.env['mail.channel.partner'].search([('channel_id', '=', self.group_channel_1.id)])
+        self.assertEqual(channel_partners.mapped('partner_id'), self.user_1.partner_id)
+
+        # user 1 can not invite user 3 because he's not in the group
+        with self.assertRaises(UserError):
+            self.group_channel_1.with_user(self.user_1).channel_invite([self.user_3.partner_id.id])
+        channel_partners = self.env['mail.channel.partner'].search([('channel_id', '=', self.group_channel_1.id)])
+        self.assertEqual(channel_partners.mapped('partner_id'), self.user_1.partner_id)
+
+        # but user 2 is in the group and can be invited by user 1
+        self.group_channel_1.with_user(self.user_1).channel_invite([self.user_2.partner_id.id])
+        channel_partners = self.env['mail.channel.partner'].search([('channel_id', '=', self.group_channel_1.id)])
+        self.assertEqual(channel_partners.mapped('partner_id'), self.user_1.partner_id | self.user_2.partner_id)
+
+    ##################
+    # PUBLIC CHANNEL #
+    ##################
+    def test_channel_acls_07(self):
+        """Test basics on public channel."""
+        channel_partners = self.env['mail.channel.partner'].search([('channel_id', '=', self.public_channel_1.id)])
+        self.assertFalse(channel_partners)
+
+        self.public_channel_1.with_user(self.user_1).action_follow()
+        channel_partners = self.env['mail.channel.partner'].search([('channel_id', '=', self.public_channel_1.id)])
+        self.assertEqual(channel_partners.mapped('partner_id'), self.user_1.partner_id)
+
+        self.public_channel_1.with_user(self.user_2).action_follow()
+        channel_partners = self.env['mail.channel.partner'].search([('channel_id', '=', self.public_channel_1.id)])
+        self.assertEqual(channel_partners.mapped('partner_id'), self.user_1.partner_id | self.user_2.partner_id)
diff --git a/addons/test_mail/tests/test_mail_composer.py b/addons/test_mail/tests/test_mail_composer.py
new file mode 100644
index 00000000..6c60ea3d
--- /dev/null
+++ b/addons/test_mail/tests/test_mail_composer.py
@@ -0,0 +1,842 @@
+# -*- coding: utf-8 -*-
+# Part of Odoo. See LICENSE file for full copyright and licensing details.
+
+import base64
+
+from unittest.mock import patch
+
+from odoo.addons.mail.tests.common import mail_new_test_user
+from odoo.addons.test_mail.models.test_mail_models import MailTestTicket
+from odoo.addons.test_mail.tests.common import TestMailCommon, TestRecipients
+from odoo.tests import tagged
+from odoo.tests.common import users, Form
+from odoo.tools import mute_logger
+
+@tagged('mail_composer')
+class TestMailComposer(TestMailCommon, TestRecipients):
+    """ Test Composer internals """
+
+    @classmethod
+    def setUpClass(cls):
+        super(TestMailComposer, cls).setUpClass()
+        cls._init_mail_gateway()
+
+        # ensure employee can create partners, necessary for templates
+        cls.user_employee.write({
+            'groups_id': [(4, cls.env.ref('base.group_partner_manager').id)],
+        })
+
+        cls.user_employee_2 = mail_new_test_user(
+            cls.env, login='employee2', groups='base.group_user',
+            notification_type='email', email='eglantine@example.com',
+            name='Eglantine Employee', signature='--\nEglantine')
+        cls.partner_employee_2 = cls.user_employee_2.partner_id
+
+        cls.test_record = cls.env['mail.test.ticket'].with_context(cls._test_context).create({
+            'name': 'TestRecord',
+            'customer_id': cls.partner_1.id,
+            'user_id': cls.user_employee_2.id,
+        })
+        cls.test_records, cls.test_partners = cls._create_records_for_batch('mail.test.ticket', 2)
+
+        cls.test_report = cls.env['ir.actions.report'].create({
+            'name': 'Test Report on mail test ticket',
+            'model': 'mail.test.ticket',
+            'report_type': 'qweb-pdf',
+            'report_name': 'test_mail.mail_test_ticket_test_template',
+        })
+        cls.test_record_report = cls.test_report._render_qweb_pdf(cls.test_report.ids)
+
+        cls.test_from = '"John Doe" <john@example.com>'
+
+        cls.mail_server = cls.env['ir.mail_server'].create({
+            'name': 'Dummy Test Server',
+            'smtp_host': 'smtp.pizza.moc',
+            'smtp_port': 17,
+            'smtp_encryption': 'ssl',
+            'sequence': 666,
+        })
+
+        cls.template = cls.env['mail.template'].create({
+            'name': 'TestTemplate',
+            'subject': 'TemplateSubject ${object.name}',
+            'body_html': '<p>TemplateBody ${object.name}</p>',
+            'partner_to': '${object.customer_id.id if object.customer_id else ""}',
+            'email_to': '${(object.email_from if not object.customer_id else "") | safe}',
+            'email_from': '${(object.user_id.email_formatted or user.email_formatted) | safe}',
+            'model_id': cls.env['ir.model']._get('mail.test.ticket').id,
+            'mail_server_id': cls.mail_server.id,
+            'auto_delete': True,
+        })
+
+    def _generate_attachments_data(self, count):
+        return [{
+            'name': '%02d.txt' % x,
+            'datas': base64.b64encode(b'Att%02d' % x),
+        } for x in range(count)]
+
+    def _get_web_context(self, records, add_web=True, **values):
+        """ Helper to generate composer context. Will make tests a bit less
+        verbose.
+
+        :param add_web: add web context, generally making noise especially in
+          mass mail mode (active_id/ids both present in context)
+        """
+        base_context = {
+            'default_model': records._name,
+        }
+        if len(records) == 1:
+            base_context['default_composition_mode'] = 'comment'
+            base_context['default_res_id'] = records.id
+        else:
+            base_context['default_composition_mode'] = 'mass_mail'
+            base_context['active_ids'] = records.ids
+        if add_web:
+            base_context['active_model'] = records._name
+            base_context['active_id'] = records[0].id
+        if values:
+            base_context.update(**values)
+        return base_context
+
+
+@tagged('mail_composer')
+class TestComposerForm(TestMailComposer):
+
+    @users('employee')
+    def test_mail_composer_comment(self):
+        composer_form = Form(self.env['mail.compose.message'].with_context(self._get_web_context(self.test_record, add_web=True)))
+        self.assertEqual(
+            composer_form.subject, 'Re: %s' % self.test_record.name,
+            'MailComposer: comment mode should have default subject Re: record_name')
+        # record name not displayed currently in view
+        # self.assertEqual(composer_form.record_name, self.test_record.name, 'MailComposer: comment mode should compute record name')
+        self.assertFalse(composer_form.no_auto_thread)
+        self.assertEqual(composer_form.composition_mode, 'comment')
+        self.assertEqual(composer_form.model, self.test_record._name)
+
+    @users('employee')
+    def test_mail_composer_comment_attachments(self):
+        """Tests that all attachments are added to the composer, static attachments
+        are not duplicated and while reports are re-generated, and that intermediary
+        attachments are dropped."""
+        attachment_data = self._generate_attachments_data(2)
+        template_1 = self.template.copy({
+            'attachment_ids': [(0, 0, a) for a in attachment_data],
+            'report_name': 'TestReport for ${object.name}.html',  # test cursor forces html
+            'report_template': self.test_report.id,
+        })
+        template_1_attachments = template_1.attachment_ids
+        self.assertEqual(len(template_1_attachments), 2)
+        template_2 = self.template.copy({
+            'attachment_ids': False,
+            'report_template': self.test_report.id,
+        })
+
+        # begins without attachments
+        composer_form = Form(self.env['mail.compose.message'].with_context(
+            self._get_web_context(self.test_record, add_web=True, default_attachment_ids=[])
+        ))
+        self.assertEqual(len(composer_form.attachment_ids), 0)
+
+        # change template: 2 static (attachment_ids) and 1 dynamic (report)
+        composer_form.template_id = template_1
+        self.assertEqual(len(composer_form.attachment_ids), 3)
+        report_attachments = [att for att in composer_form.attachment_ids if att not in template_1_attachments]
+        self.assertEqual(len(report_attachments), 1)
+        tpl_attachments = composer_form.attachment_ids[:] - report_attachments[0]
+        self.assertEqual(tpl_attachments, template_1_attachments)
+
+        # change template: 0 static (attachment_ids) and 1 dynamic (report)
+        composer_form.template_id = template_2
+        self.assertEqual(len(composer_form.attachment_ids), 1)
+        report_attachments = [att for att in composer_form.attachment_ids if att not in template_1_attachments]
+        self.assertEqual(len(report_attachments), 1)
+        tpl_attachments = composer_form.attachment_ids[:] - report_attachments[0]
+        self.assertEqual(tpl_attachments, self.env['ir.attachment'])
+
+        # change back to template 1
+        composer_form.template_id = template_1
+        self.assertEqual(len(composer_form.attachment_ids), 3)
+        report_attachments = [att for att in composer_form.attachment_ids if att not in template_1_attachments]
+        self.assertEqual(len(report_attachments), 1)
+        tpl_attachments = composer_form.attachment_ids[:] - report_attachments[0]
+        self.assertEqual(tpl_attachments, template_1_attachments)
+
+        # reset template
+        composer_form.template_id = self.env['mail.template']
+        self.assertEqual(len(composer_form.attachment_ids), 0)
+
+    @users('employee')
+    def test_mail_composer_mass(self):
+        composer_form = Form(self.env['mail.compose.message'].with_context(self._get_web_context(self.test_records, add_web=True)))
+        self.assertFalse(composer_form.subject, 'MailComposer: mass mode should have void default subject if no template')
+        # record name not displayed currently in view
+        # self.assertFalse(composer_form.record_name, 'MailComposer: mass mode should have void record name')
+        self.assertFalse(composer_form.no_auto_thread)
+        self.assertEqual(composer_form.composition_mode, 'mass_mail')
+        self.assertEqual(composer_form.model, self.test_records._name)
+
+    @users('employee')
+    def test_mail_composer_mass_wtpl(self):
+        ctx = self._get_web_context(self.test_records, add_web=True, default_template_id=self.template.id)
+        composer_form = Form(self.env['mail.compose.message'].with_context(ctx))
+        self.assertEqual(composer_form.subject, self.template.subject,
+                         'MailComposer: mass mode should have template raw subject if template')
+        self.assertEqual(composer_form.body, self.template.body_html,
+                         'MailComposer: mass mode should have template raw body if template')
+        # record name not displayed currently in view
+        # self.assertFalse(composer_form.record_name, 'MailComposer: mass mode should have void record name')
+        self.assertFalse(composer_form.no_auto_thread)
+        self.assertEqual(composer_form.composition_mode, 'mass_mail')
+        self.assertEqual(composer_form.model, self.test_records._name)
+
+
+@tagged('mail_composer')
+class TestComposerInternals(TestMailComposer):
+
+    @users('employee')
+    @mute_logger('odoo.addons.mail.models.mail_mail')
+    def test_mail_composer_attachments_comment(self):
+        """ Test attachments management in comment mode. """
+        attachment_data = self._generate_attachments_data(3)
+        self.template.write({
+            'attachment_ids': [(0, 0, a) for a in attachment_data],
+            'report_name': 'TestReport for ${object.name}.html',  # test cursor forces html
+            'report_template': self.test_report.id,
+        })
+        attachs = self.env['ir.attachment'].search([('name', 'in', [a['name'] for a in attachment_data])])
+        self.assertEqual(len(attachs), 3)
+
+        composer = self.env['mail.compose.message'].with_context({
+            'default_composition_mode': 'comment',
+            'default_model': self.test_record._name,
+            'default_res_id': self.test_record.id,
+            'default_template_id': self.template.id,
+        }).create({
+            'body': '<p>Test Body</p>',
+        })
+        # currently onchange necessary
+        composer.onchange_template_id_wrapper()
+
+        # values coming from template
+        self.assertEqual(len(composer.attachment_ids), 4)
+        for attach in attachs:
+            self.assertIn(attach, composer.attachment_ids)
+        generated = composer.attachment_ids - attachs
+        self.assertEqual(len(generated), 1, 'MailComposer: should have 1 additional attachment for report')
+        self.assertEqual(generated.name, 'TestReport for %s.html' % self.test_record.name)
+        self.assertEqual(generated.res_model, 'mail.compose.message')
+        self.assertEqual(generated.res_id, 0)
+
+    @users('employee')
+    @mute_logger('odoo.addons.mail.models.mail_mail')
+    def test_mail_composer_author(self):
+        """ Test author_id / email_from synchronization, in both comment and mass mail
+        modes. """
+        for composition_mode in ['comment', 'mass_mail']:
+            if composition_mode == 'comment':
+                ctx = self._get_web_context(self.test_record, add_web=False)
+            else:
+                ctx = self._get_web_context(self.test_records, add_web=False)
+            composer = self.env['mail.compose.message'].with_context(ctx).create({
+                'body': '<p>Test Body</p>',
+            })
+
+            # default values are current user
+            self.assertEqual(composer.author_id, self.env.user.partner_id)
+            self.assertEqual(composer.email_from, self.env.user.email_formatted)
+
+            # author values reset email (FIXME: currently not synchronized)
+            composer.write({'author_id': self.partner_1})
+            self.assertEqual(composer.author_id, self.partner_1)
+            self.assertEqual(composer.email_from, self.env.user.email_formatted)
+            # self.assertEqual(composer.email_from, self.partner_1.email_formatted)
+
+            # changing template should update its email_from
+            composer.write({'template_id': self.template.id, 'author_id': self.env.user.partner_id})
+            # currently onchange necessary
+            composer.onchange_template_id_wrapper()
+            self.assertEqual(composer.author_id, self.env.user.partner_id,
+                             'MailComposer: should take value given by user')
+            if composition_mode == 'comment':
+                self.assertEqual(composer.email_from, self.test_record.user_id.email_formatted,
+                                 'MailComposer: should take email_from rendered from template')
+            else:
+                self.assertEqual(composer.email_from, self.template.email_from,
+                                 'MailComposer: should take email_from raw from template')
+
+            # manual values are kept over template values
+            composer.write({'email_from': self.test_from})
+            self.assertEqual(composer.author_id, self.env.user.partner_id)
+            self.assertEqual(composer.email_from, self.test_from)
+
+    @users('employee')
+    def test_mail_composer_content(self):
+        """ Test content management (subject, body, server) in both comment and
+        mass mailing mode. Template update is also tested. """
+        for composition_mode in ['comment', 'mass_mail']:
+            if composition_mode == 'comment':
+                ctx = self._get_web_context(self.test_record, add_web=False)
+            else:
+                ctx = self._get_web_context(self.test_records, add_web=False)
+
+            # 1. check without template + template update
+            composer = self.env['mail.compose.message'].with_context(ctx).create({
+                'subject': 'My amazing subject',
+                'body': '<p>Test Body</p>',
+            })
+
+            # creation values are taken
+            self.assertEqual(composer.subject, 'My amazing subject')
+            self.assertEqual(composer.body, '<p>Test Body</p>')
+            self.assertEqual(composer.mail_server_id.id, False)
+
+            # changing template should update its content
+            composer.write({'template_id': self.template.id})
+            # currently onchange necessary
+            composer.onchange_template_id_wrapper()
+
+            # values come from template
+            if composition_mode == 'comment':
+                self.assertEqual(composer.subject, 'TemplateSubject %s' % self.test_record.name)
+                self.assertEqual(composer.body, '<p>TemplateBody %s</p>' % self.test_record.name)
+                self.assertEqual(composer.mail_server_id, self.template.mail_server_id)
+            else:
+                self.assertEqual(composer.subject, self.template.subject)
+                self.assertEqual(composer.body, self.template.body_html)
+                self.assertEqual(composer.mail_server_id, self.template.mail_server_id)
+
+            # manual values is kept over template
+            composer.write({'subject': 'Back to my amazing subject'})
+            self.assertEqual(composer.subject, 'Back to my amazing subject')
+
+            # reset template should reset values
+            composer.write({'template_id': False})
+            # currently onchange necessary
+            composer.onchange_template_id_wrapper()
+
+            # values are reset
+            if composition_mode == 'comment':
+                self.assertEqual(composer.subject, 'Re: %s' % self.test_record.name)
+                self.assertEqual(composer.body, '')
+                # TDE FIXME: server id is kept, not sure why
+                # self.assertFalse(composer.mail_server_id.id)
+                self.assertEqual(composer.mail_server_id, self.template.mail_server_id)
+            else:
+                # values are reset TDE FIXME: strange for subject
+                self.assertEqual(composer.subject, 'Back to my amazing subject')
+                self.assertEqual(composer.body, '')
+                # TDE FIXME: server id is kept, not sure why
+                # self.assertFalse(composer.mail_server_id.id)
+                self.assertEqual(composer.mail_server_id, self.template.mail_server_id)
+
+            # 2. check with default
+            ctx['default_template_id'] = self.template.id
+            composer = self.env['mail.compose.message'].with_context(ctx).create({
+                'template_id': self.template.id,
+            })
+            # currently onchange necessary
+            composer.onchange_template_id_wrapper()
+
+            # values come from template
+            if composition_mode == 'comment':
+                self.assertEqual(composer.subject, 'TemplateSubject %s' % self.test_record.name)
+                self.assertEqual(composer.body, '<p>TemplateBody %s</p>' % self.test_record.name)
+                self.assertEqual(composer.mail_server_id, self.template.mail_server_id)
+            else:
+                self.assertEqual(composer.subject, self.template.subject)
+                self.assertEqual(composer.body, self.template.body_html)
+                self.assertEqual(composer.mail_server_id, self.template.mail_server_id)
+
+            # 3. check at create
+            ctx.pop('default_template_id')
+            composer = self.env['mail.compose.message'].with_context(ctx).create({
+                'template_id': self.template.id,
+            })
+            # currently onchange necessary
+            composer.onchange_template_id_wrapper()
+
+            # values come from template
+            if composition_mode == 'comment':
+                self.assertEqual(composer.subject, 'TemplateSubject %s' % self.test_record.name)
+                self.assertEqual(composer.body, '<p>TemplateBody %s</p>' % self.test_record.name)
+                self.assertEqual(composer.mail_server_id, self.template.mail_server_id)
+            else:
+                self.assertEqual(composer.subject, self.template.subject)
+                self.assertEqual(composer.body, self.template.body_html)
+                self.assertEqual(composer.mail_server_id, self.template.mail_server_id)
+
+            # 4. template + user input
+            ctx['default_template_id'] = self.template.id
+            composer = self.env['mail.compose.message'].with_context(ctx).create({
+                'subject': 'My amazing subject',
+                'body': '<p>Test Body</p>',
+                'mail_server_id': False,
+            })
+
+            # creation values are taken
+            self.assertEqual(composer.subject, 'My amazing subject')
+            self.assertEqual(composer.body, '<p>Test Body</p>')
+            self.assertEqual(composer.mail_server_id.id, False)
+
+    @users('employee')
+    @mute_logger('odoo.tests', 'odoo.addons.mail.models.mail_mail')
+    def test_mail_composer_parent(self):
+        """ Test specific management in comment mode when having parent_id set:
+        record_name, subject, parent's partners. """
+        parent = self.test_record.message_post(body='Test', partner_ids=(self.partner_1 + self.partner_2).ids)
+
+        composer = self.env['mail.compose.message'].with_context(
+            self._get_web_context(self.test_record, add_web=False, default_parent_id=parent.id)
+        ).create({
+            'body': '<p>Test Body</p>',
+        })
+
+        # creation values taken from parent
+        self.assertEqual(composer.subject, 'Re: %s' % self.test_record.name)
+        self.assertEqual(composer.body, '<p>Test Body</p>')
+        self.assertEqual(composer.partner_ids, self.partner_1 + self.partner_2)
+
+    def test_mail_composer_rights_portal(self):
+        portal_user = self._create_portal_user()
+
+        with patch.object(MailTestTicket, 'check_access_rights', return_value=True):
+            self.env['mail.compose.message'].with_user(portal_user).with_context(
+                self._get_web_context(self.test_record)
+            ).create({
+                'subject': 'Subject',
+                'body': '<p>Body text</p>',
+                'partner_ids': []
+            }).send_mail()
+
+            self.assertEqual(self.test_record.message_ids[0].body, '<p>Body text</p>')
+            self.assertEqual(self.test_record.message_ids[0].author_id, portal_user.partner_id)
+
+            self.env['mail.compose.message'].with_user(portal_user).with_context({
+                'default_composition_mode': 'comment',
+                'default_parent_id': self.test_record.message_ids.ids[0],
+            }).create({
+                'subject': 'Subject',
+                'body': '<p>Body text 2</p>'
+            }).send_mail()
+
+            self.assertEqual(self.test_record.message_ids[0].body, '<p>Body text 2</p>')
+            self.assertEqual(self.test_record.message_ids[0].author_id, portal_user.partner_id)
+
+    @users('employee')
+    def test_mail_composer_save_template(self):
+        self.env['mail.compose.message'].with_context(
+            self._get_web_context(self.test_record, add_web=False)
+        ).create({
+            'subject': 'Template Subject',
+            'body': '<p>Template Body</p>',
+        }).save_as_template()
+
+        # Test: email_template subject, body_html, model
+        template = self.env['mail.template'].search([
+            ('model', '=', self.test_record._name),
+            ('subject', '=', 'Template Subject')
+        ], limit=1)
+        self.assertEqual(template.name, "%s: %s" % (self.env['ir.model']._get(self.test_record._name).name, 'Template Subject'))
+        self.assertEqual(template.body_html, '<p>Template Body</p>', 'email_template incorrect body_html')
+
+
+@tagged('mail_composer')
+class TestComposerResultsComment(TestMailComposer):
+    """ Test global output of composer used in comment mode. Test notably
+    notification and emails generated during this process. """
+
+    @users('employee')
+    @mute_logger('odoo.tests', 'odoo.addons.mail.models.mail_mail')
+    def test_mail_composer_notifications_delete(self):
+        """ Notifications are correctly deleted once sent """
+        composer = self.env['mail.compose.message'].with_context(
+            self._get_web_context(self.test_record)
+        ).create({
+            'body': '<p>Test Body</p>',
+            'partner_ids': [(4, self.partner_1.id), (4, self.partner_2.id)]
+        })
+        with self.mock_mail_gateway(mail_unlink_sent=True):
+            composer.send_mail()
+
+        # notifications
+        message = self.test_record.message_ids[0]
+        self.assertEqual(message.notified_partner_ids, self.partner_employee_2 + self.partner_1 + self.partner_2)
+
+        # global outgoing
+        self.assertEqual(len(self._new_mails), 2, 'Should have created 2 mail.mail (1 for users, 1 for customers)')
+        self.assertEqual(len(self._mails), 3, 'Should have sent an email each recipient')
+        self.assertEqual(self._new_mails.exists(), self.env['mail.mail'], 'Should have deleted mail.mail records')
+
+        # ensure ``mail_auto_delete`` context key allow to override this behavior
+        composer = self.env['mail.compose.message'].with_context(
+            self._get_web_context(self.test_record),
+            mail_auto_delete=False,
+        ).create({
+            'body': '<p>Test Body</p>',
+            'partner_ids': [(4, self.partner_1.id), (4, self.partner_2.id)]
+        })
+        with self.mock_mail_gateway(mail_unlink_sent=True):
+            composer.send_mail()
+
+        # notifications
+        message = self.test_record.message_ids[0]
+        self.assertEqual(message.notified_partner_ids, self.partner_employee_2 + self.partner_1 + self.partner_2)
+
+        # global outgoing
+        self.assertEqual(len(self._new_mails), 2, 'Should have created 2 mail.mail (1 for users, 1 for customers)')
+        self.assertEqual(len(self._mails), 3, 'Should have sent an email each recipient')
+        self.assertEqual(len(self._new_mails.exists()), 2, 'Should not have deleted mail.mail records')
+
+    @users('employee')
+    @mute_logger('odoo.tests', 'odoo.addons.mail.models.mail_mail')
+    def test_mail_composer_recipients(self):
+        """ Test partner_ids given to composer are given to the final message. """
+        composer = self.env['mail.compose.message'].with_context(
+            self._get_web_context(self.test_record)
+        ).create({
+            'body': '<p>Test Body</p>',
+            'partner_ids': [(4, self.partner_1.id), (4, self.partner_2.id)]
+        })
+        composer.send_mail()
+
+        message = self.test_record.message_ids[0]
+        self.assertEqual(message.body, '<p>Test Body</p>')
+        self.assertEqual(message.author_id, self.user_employee.partner_id)
+        self.assertEqual(message.subject, 'Re: %s' % self.test_record.name)
+        self.assertEqual(message.subtype_id, self.env.ref('mail.mt_comment'))
+        self.assertEqual(message.partner_ids, self.partner_1 | self.partner_2)
+
+    @users('employee')
+    @mute_logger('odoo.models.unlink', 'odoo.addons.mail.models.mail_mail')
+    def test_mail_composer_wtpl_complete(self):
+        """ Test a posting process using a complex template, holding several
+        additional recipients and attachments.
+
+        This tests notifies: 2 new email_to (+ 1 duplicated), 1 email_cc,
+        test_record followers and partner_admin added in partner_to."""
+        attachment_data = self._generate_attachments_data(2)
+        email_to_1 = 'test.to.1@test.example.com'
+        email_to_2 = 'test.to.2@test.example.com'
+        email_to_3 = 'test.to.1@test.example.com'  # duplicate: should not sent twice the email
+        email_cc_1 = 'test.cc.1@test.example.com'
+        self.template.write({
+            'auto_delete': False,  # keep sent emails to check content
+            'attachment_ids': [(0, 0, a) for a in attachment_data],
+            'email_to': '%s, %s, %s' % (email_to_1, email_to_2, email_to_3),
+            'email_cc': email_cc_1,
+            'partner_to': '%s, ${object.customer_id.id if object.customer_id else ""}' % self.partner_admin.id,
+            'report_name': 'TestReport for ${object.name}',  # test cursor forces html
+            'report_template': self.test_report.id,
+        })
+        attachs = self.env['ir.attachment'].search([('name', 'in', [a['name'] for a in attachment_data])])
+        self.assertEqual(len(attachs), 2)
+
+        # ensure initial data
+        self.assertEqual(self.test_record.user_id, self.user_employee_2)
+        self.assertEqual(self.test_record.message_partner_ids, self.partner_employee_2)
+
+        # open a composer and run it in comment mode
+        composer_form = Form(self.env['mail.compose.message'].with_context(
+            self._get_web_context(self.test_record, add_web=True,
+                                  default_template_id=self.template.id)
+        ))
+        composer = composer_form.save()
+        with self.mock_mail_gateway(mail_unlink_sent=False), self.mock_mail_app():
+            composer.send_mail()
+
+        # check new partners have been created based on emails given
+        new_partners = self.env['res.partner'].search([
+            ('email', 'in', [email_to_1, email_to_2, email_to_3, email_cc_1])
+        ])
+        self.assertEqual(len(new_partners), 3)
+        self.assertEqual(set(new_partners.mapped('email')),
+                         set(['test.to.1@test.example.com', 'test.to.2@test.example.com', 'test.cc.1@test.example.com'])
+                        )
+
+        # global outgoing: one mail.mail (all customer recipients, then all employee recipients)
+        # and 5 emails, and 1 inbox notification (admin)
+        self.assertEqual(len(self._new_mails), 2, 'Should have created 1 mail.mail')
+        self.assertEqual(len(self._mails), 5, 'Should have sent 5 emails, one per recipient')
+
+        # template is sent only to partners (email_to are transformed)
+        message = self.test_record.message_ids[0]
+        self.assertMailMail(self.partner_employee_2, 'sent',
+                            mail_message=message,
+                            author=self.partner_employee,  # author != email_from (template sets only email_from)
+                            email_values={
+                                'body_content': 'TemplateBody %s' % self.test_record.name,
+                                'email_from': self.test_record.user_id.email_formatted,  # set by template
+                                'subject': 'TemplateSubject %s' % self.test_record.name,
+                                'attachments_info': [
+                                    {'name': '00.txt', 'raw': b'Att00', 'type': 'text/plain'},
+                                    {'name': '01.txt', 'raw': b'Att01', 'type': 'text/plain'},
+                                    {'name': 'TestReport for %s.html' % self.test_record.name, 'type': 'text/plain'},
+                                ]
+                            },
+                            fields_values={},
+                           )
+        self.assertMailMail(self.test_record.customer_id + new_partners, 'sent',
+                            mail_message=message,
+                            author=self.partner_employee,  # author != email_from (template sets only email_from)
+                            email_values={
+                                'body_content': 'TemplateBody %s' % self.test_record.name,
+                                'email_from': self.test_record.user_id.email_formatted,  # set by template
+                                'subject': 'TemplateSubject %s' % self.test_record.name,
+                                'attachments_info': [
+                                    {'name': '00.txt', 'raw': b'Att00', 'type': 'text/plain'},
+                                    {'name': '01.txt', 'raw': b'Att01', 'type': 'text/plain'},
+                                    {'name': 'TestReport for %s.html' % self.test_record.name, 'type': 'text/plain'},
+                                ]
+                            },
+                            fields_values={},
+                           )
+
+        # message is posted and notified admin
+        self.assertEqual(message.subtype_id, self.env.ref('mail.mt_comment'))
+        self.assertNotified(message, [{'partner': self.partner_admin, 'is_read': False, 'type': 'inbox'}])
+        # attachments are copied on message and linked to document
+        self.assertEqual(
+            set(message.attachment_ids.mapped('name')),
+            set(['00.txt', '01.txt', 'TestReport for %s.html' % self.test_record.name])
+        )
+        self.assertEqual(set(message.attachment_ids.mapped('res_model')), set([self.test_record._name]))
+        self.assertEqual(set(message.attachment_ids.mapped('res_id')), set(self.test_record.ids))
+        self.assertTrue(all(attach not in message.attachment_ids for attach in attachs), 'Should have copied attachments')
+
+
+@tagged('mail_composer')
+class TestComposerResultsMass(TestMailComposer):
+
+    @classmethod
+    def setUpClass(cls):
+        super(TestComposerResultsMass, cls).setUpClass()
+        # ensure employee can create partners, necessary for templates
+        cls.user_employee.write({
+            'groups_id': [(4, cls.env.ref('base.group_partner_manager').id)],
+        })
+
+    @users('employee')
+    @mute_logger('odoo.models.unlink', 'odoo.addons.mail.models.mail_mail')
+    def test_mail_composer_wtpl(self):
+        self.template.auto_delete = False  # keep sent emails to check content
+        composer_form = Form(self.env['mail.compose.message'].with_context(
+            self._get_web_context(self.test_records, add_web=True,
+                                  default_template_id=self.template.id)
+        ))
+        composer = composer_form.save()
+        with self.mock_mail_gateway(mail_unlink_sent=True):
+            composer.send_mail()
+
+        # global outgoing
+        self.assertEqual(len(self._new_mails), 2, 'Should have created 1 mail.mail per record')
+        self.assertEqual(len(self._mails), 2, 'Should have sent 1 email per record')
+
+        for record in self.test_records:
+            # message copy is kept
+            message = record.message_ids[0]
+
+            # template is sent directly using customer field, meaning we have recipients
+            self.assertMailMail(record.customer_id, 'sent',
+                                mail_message=message,
+                                author=self.partner_employee)
+
+            # message content
+            self.assertEqual(message.subject, 'TemplateSubject %s' % record.name)
+            self.assertEqual(message.body, '<p>TemplateBody %s</p>' % record.name)
+            self.assertEqual(message.author_id, self.user_employee.partner_id)
+            # post-related fields are void
+            self.assertEqual(message.subtype_id, self.env['mail.message.subtype'])
+            self.assertEqual(message.partner_ids, self.env['res.partner'])
+
+    @users('employee')
+    @mute_logger('odoo.models.unlink', 'odoo.addons.mail.models.mail_mail')
+    def test_mail_composer_wtpl_complete(self):
+        """ Test a composer in mass mode with a quite complete template, containing
+        notably email-based recipients and attachments. """
+        attachment_data = self._generate_attachments_data(2)
+        email_to_1 = 'test.to.1@test.example.com'
+        email_to_2 = 'test.to.2@test.example.com'
+        email_to_3 = 'test.to.1@test.example.com'  # duplicate: should not sent twice the email
+        email_cc_1 = 'test.cc.1@test.example.com'
+        self.template.write({
+            'auto_delete': False,  # keep sent emails to check content
+            'attachment_ids': [(0, 0, a) for a in attachment_data],
+            'email_to': '%s, %s, %s' % (email_to_1, email_to_2, email_to_3),
+            'email_cc': email_cc_1,
+            'partner_to': '%s, ${object.customer_id.id if object.customer_id else ""}' % self.partner_admin.id,
+            'report_name': 'TestReport for ${object.name}',  # test cursor forces html
+            'report_template': self.test_report.id,
+        })
+        attachs = self.env['ir.attachment'].search([('name', 'in', [a['name'] for a in attachment_data])])
+        self.assertEqual(len(attachs), 2)
+
+        # ensure initial data
+        self.assertEqual(self.test_records.user_id, self.env['res.users'])
+        self.assertEqual(self.test_records.message_partner_ids, self.env['res.partner'])
+
+        # launch composer in mass mode
+        composer_form = Form(self.env['mail.compose.message'].with_context(
+            self._get_web_context(self.test_records, add_web=True,
+                                  default_template_id=self.template.id)
+        ))
+        composer = composer_form.save()
+        with self.mock_mail_gateway(mail_unlink_sent=False):
+            composer.send_mail()
+
+        new_partners = self.env['res.partner'].search([
+            ('email', 'in', [email_to_1, email_to_2, email_to_3, email_cc_1])
+        ])
+        self.assertEqual(len(new_partners), 3)
+
+        # global outgoing
+        self.assertEqual(len(self._new_mails), 2, 'Should have created 1 mail.mail per record')
+        self.assertEqual(len(self._mails), 10, 'Should have sent 5 emails per record')
+
+        # hack to use assertEmails: filtering on from/to only is not sufficient to distinguish emails
+        _mails_records = [
+            [mail for mail in self._mails if '%s-%s' % (record.id, record._name) in mail['message_id']]
+            for record in self.test_records
+        ]
+        _mails_record2 = [mail for mail in self._mails if '%s-%s' % (self.test_records[1].id, self.test_records._name) in mail['message_id']]
+
+        for record, _mails in zip(self.test_records, _mails_records):
+            # message copy is kept
+            message = record.message_ids[0]
+
+            # template is sent only to partners (email_to are transformed)
+            self._mails = _mails
+            self.assertMailMail(record.customer_id + new_partners + self.partner_admin,
+                                'sent',
+                                mail_message=message,
+                                author=self.partner_employee,
+                                email_values={
+                                    'body_content': 'TemplateBody %s' % record.name,
+                                    'subject': 'TemplateSubject %s' % record.name,
+                                    # 'attachments': [
+                                    #     ('00.txt', b'Att00', 'text/plain'),
+                                    #     ('01.txt', b'Att01', 'text/plain'),
+                                    #     ('report.test_mail.mail_test_ticket_test_template.html', b'My second attachment', 'text/plain')
+                                    # ]
+                                }
+                               )
+
+    @users('employee')
+    @mute_logger('odoo.models.unlink', 'odoo.addons.mail.models.mail_mail')
+    def test_mail_composer_wtpl_delete(self):
+        self.template.auto_delete = True
+        composer_form = Form(self.env['mail.compose.message'].with_context(
+            self._get_web_context(self.test_records, add_web=True,
+                                  default_template_id=self.template.id)
+        ))
+        composer = composer_form.save()
+        with self.mock_mail_gateway(mail_unlink_sent=True):
+            composer.send_mail()
+
+        # global outgoing
+        self.assertEqual(len(self._new_mails), 2, 'Should have created 1 mail.mail per record')
+        self.assertEqual(len(self._mails), 2, 'Should have sent 1 email per record')
+        self.assertEqual(self._new_mails.exists(), self.env['mail.mail'], 'Should have deleted mail.mail records')
+
+        for record in self.test_records:
+            # message copy is kept
+            message = record.message_ids[0]
+
+            # template is sent directly using customer field
+            self.assertSentEmail(self.partner_employee, record.customer_id)
+
+            # message content
+            self.assertEqual(message.subject, 'TemplateSubject %s' % record.name)
+            self.assertEqual(message.body, '<p>TemplateBody %s</p>' % record.name)
+            self.assertEqual(message.author_id, self.user_employee.partner_id)
+            # post-related fields are void
+            self.assertEqual(message.subtype_id, self.env['mail.message.subtype'])
+            self.assertEqual(message.partner_ids, self.env['res.partner'])
+
+    @users('employee')
+    @mute_logger('odoo.models.unlink', 'odoo.addons.mail.models.mail_mail')
+    def test_mail_composer_wtpl_delete_notif(self):
+        self.template.auto_delete = True
+        composer_form = Form(self.env['mail.compose.message'].with_context(
+            self._get_web_context(self.test_records, add_web=True,
+                                  default_template_id=self.template.id,
+                                  default_auto_delete_message=True)
+        ))
+        composer = composer_form.save()
+        with self.mock_mail_gateway(mail_unlink_sent=True):
+            composer.send_mail()
+
+        # global outgoing
+        self.assertEqual(len(self._new_mails), 2, 'Should have created 1 mail.mail per record')
+        self.assertEqual(len(self._mails), 2, 'Should have sent 1 email per record')
+        self.assertEqual(self._new_mails.exists(), self.env['mail.mail'], 'Should have deleted mail.mail records')
+
+        for record in self.test_records:
+            # message copy is unlinked
+            self.assertEqual(record.message_ids, self.env['mail.message'], 'Should have deleted mail.message records')
+
+            # template is sent directly using customer field
+            self.assertSentEmail(self.partner_employee, record.customer_id)
+
+    @users('employee')
+    @mute_logger('odoo.models.unlink', 'odoo.addons.mail.models.mail_mail')
+    def test_mail_composer_wtpl_recipients(self):
+        """ Test various combinations of recipients: active_domain, active_id,
+        active_ids, ... to ensure fallback behavior are working. """
+        # 1: active_domain
+        composer_form = Form(self.env['mail.compose.message'].with_context(
+            self._get_web_context(self.test_records, add_web=True,
+                                  default_template_id=self.template.id,
+                                  active_ids=[],
+                                  default_use_active_domain=True,
+                                  default_active_domain=[('id', 'in', self.test_records.ids)])
+        ))
+        composer = composer_form.save()
+        with self.mock_mail_gateway(mail_unlink_sent=True):
+            composer.send_mail()
+
+        # global outgoing
+        self.assertEqual(len(self._new_mails), 2, 'Should have created 1 mail.mail per record')
+        self.assertEqual(len(self._mails), 2, 'Should have sent 1 email per record')
+
+        for record in self.test_records:
+            # template is sent directly using customer field
+            self.assertSentEmail(self.partner_employee, record.customer_id)
+
+        # 2: active_domain not taken into account if use_active_domain is False
+        composer_form = Form(self.env['mail.compose.message'].with_context(
+            self._get_web_context(self.test_records, add_web=True,
+                                  default_template_id=self.template.id,
+                                  default_use_active_domain=False,
+                                  default_active_domain=[('id', 'in', -1)])
+        ))
+        composer = composer_form.save()
+        with self.mock_mail_gateway(mail_unlink_sent=True):
+            composer.send_mail()
+
+        # global outgoing
+        self.assertEqual(len(self._new_mails), 2, 'Should have created 1 mail.mail per record')
+        self.assertEqual(len(self._mails), 2, 'Should have sent 1 email per record')
+
+        # 3: fallback on active_id if not active_ids
+        composer_form = Form(self.env['mail.compose.message'].with_context(
+            self._get_web_context(self.test_records, add_web=True,
+                                  default_template_id=self.template.id,
+                                  active_ids=[])
+        ))
+        composer = composer_form.save()
+        with self.mock_mail_gateway(mail_unlink_sent=False):
+            composer.send_mail()
+
+        # global outgoing
+        self.assertEqual(len(self._new_mails), 1, 'Should have created 1 mail.mail per record')
+        self.assertEqual(len(self._mails), 1, 'Should have sent 1 email per record')
+
+        # 3: void is void
+        composer_form = Form(self.env['mail.compose.message'].with_context(
+            default_model='mail.test.ticket',
+            default_template_id=self.template.id
+        ))
+        composer = composer_form.save()
+        with self.mock_mail_gateway(mail_unlink_sent=False), self.assertRaises(ValueError):
+            composer.send_mail()
diff --git a/addons/test_mail/tests/test_mail_followers.py b/addons/test_mail/tests/test_mail_followers.py
new file mode 100644
index 00000000..9246073a
--- /dev/null
+++ b/addons/test_mail/tests/test_mail_followers.py
@@ -0,0 +1,498 @@
+# -*- coding: utf-8 -*-
+# Part of Odoo. See LICENSE file for full copyright and licensing details.
+
+from psycopg2 import IntegrityError
+
+from odoo.addons.test_mail.tests.common import TestMailCommon
+from odoo.tests import tagged
+from odoo.tests import users
+from odoo.tools.misc import mute_logger
+
+
+@tagged('mail_followers')
+class BaseFollowersTest(TestMailCommon):
+
+    @classmethod
+    def setUpClass(cls):
+        super(BaseFollowersTest, cls).setUpClass()
+        cls.test_record = cls.env['mail.test.simple'].with_context(cls._test_context).create({'name': 'Test', 'email_from': 'ignasse@example.com'})
+        cls._create_portal_user()
+        cls._create_channel_listener()
+
+        # allow employee to update partners
+        cls.user_employee.write({'groups_id': [(4, cls.env.ref('base.group_partner_manager').id)]})
+
+        Subtype = cls.env['mail.message.subtype']
+        # global
+        cls.mt_al_def = Subtype.create({'name': 'mt_al_def', 'default': True, 'res_model': False})
+        cls.mt_al_nodef = Subtype.create({'name': 'mt_al_nodef', 'default': False, 'res_model': False})
+        # mail.test.simple
+        cls.mt_mg_def = Subtype.create({'name': 'mt_mg_def', 'default': True, 'res_model': 'mail.test.simple'})
+        cls.mt_mg_nodef = Subtype.create({'name': 'mt_mg_nodef', 'default': False, 'res_model': 'mail.test.simple'})
+        cls.mt_mg_def_int = Subtype.create({'name': 'mt_mg_def', 'default': True, 'res_model': 'mail.test.simple', 'internal': True})
+        # mail.test.container
+        cls.mt_cl_def = Subtype.create({'name': 'mt_cl_def', 'default': True, 'res_model': 'mail.test.container'})
+
+        cls.default_group_subtypes = Subtype.search([('default', '=', True), '|', ('res_model', '=', 'mail.test.simple'), ('res_model', '=', False)])
+        cls.default_group_subtypes_portal = Subtype.search([('internal', '=', False), ('default', '=', True), '|', ('res_model', '=', 'mail.test.simple'), ('res_model', '=', False)])
+
+    def test_field_message_is_follower(self):
+        test_record = self.test_record.with_user(self.user_employee)
+        followed_before = test_record.search([('message_is_follower', '=', True)])
+        self.assertFalse(test_record.message_is_follower)
+        test_record.message_subscribe(partner_ids=[self.user_employee.partner_id.id])
+        followed_after = test_record.search([('message_is_follower', '=', True)])
+        self.assertTrue(test_record.message_is_follower)
+        self.assertEqual(followed_before | test_record, followed_after)
+
+    def test_field_followers(self):
+        test_record = self.test_record.with_user(self.user_employee)
+        test_record.message_subscribe(partner_ids=[self.user_employee.partner_id.id, self.user_admin.partner_id.id], channel_ids=[self.channel_listen.id])
+        followers = self.env['mail.followers'].search([
+            ('res_model', '=', 'mail.test.simple'),
+            ('res_id', '=', test_record.id)])
+        self.assertEqual(followers, test_record.message_follower_ids)
+        self.assertEqual(test_record.message_partner_ids, self.user_employee.partner_id | self.user_admin.partner_id)
+        self.assertEqual(test_record.message_channel_ids, self.channel_listen)
+
+    def test_followers_subtypes_default(self):
+        test_record = self.test_record.with_user(self.user_employee)
+        test_record.message_subscribe(partner_ids=[self.user_employee.partner_id.id])
+        self.assertEqual(test_record.message_partner_ids, self.user_employee.partner_id)
+        follower = self.env['mail.followers'].search([
+            ('res_model', '=', 'mail.test.simple'),
+            ('res_id', '=', test_record.id),
+            ('partner_id', '=', self.user_employee.partner_id.id)])
+        self.assertEqual(follower, test_record.message_follower_ids)
+        self.assertEqual(follower.subtype_ids, self.default_group_subtypes)
+
+    def test_followers_subtypes_default_internal(self):
+        test_record = self.test_record.with_user(self.user_employee)
+        test_record.message_subscribe(partner_ids=[self.partner_portal.id])
+        self.assertEqual(test_record.message_partner_ids, self.partner_portal)
+        follower = self.env['mail.followers'].search([
+            ('res_model', '=', 'mail.test.simple'),
+            ('res_id', '=', test_record.id),
+            ('partner_id', '=', self.partner_portal.id)])
+        self.assertEqual(follower.subtype_ids, self.default_group_subtypes_portal)
+
+    def test_followers_subtypes_specified(self):
+        test_record = self.test_record.with_user(self.user_employee)
+        test_record.message_subscribe(partner_ids=[self.user_employee.partner_id.id], subtype_ids=[self.mt_mg_nodef.id])
+        self.assertEqual(test_record.message_partner_ids, self.user_employee.partner_id)
+        follower = self.env['mail.followers'].search([
+            ('res_model', '=', 'mail.test.simple'),
+            ('res_id', '=', test_record.id),
+            ('partner_id', '=', self.user_employee.partner_id.id)])
+        self.assertEqual(follower, test_record.message_follower_ids)
+        self.assertEqual(follower.subtype_ids, self.mt_mg_nodef)
+
+    def test_followers_multiple_subscription_force(self):
+        test_record = self.test_record.with_user(self.user_employee)
+
+        test_record.message_subscribe(partner_ids=[self.user_admin.partner_id.id], subtype_ids=[self.mt_mg_nodef.id])
+        self.assertEqual(test_record.message_partner_ids, self.user_admin.partner_id)
+        self.assertEqual(test_record.message_channel_ids, self.env['mail.channel'])
+        self.assertEqual(test_record.message_follower_ids.subtype_ids, self.mt_mg_nodef)
+
+        test_record.message_subscribe(partner_ids=[self.user_admin.partner_id.id], subtype_ids=[self.mt_mg_nodef.id, self.mt_al_nodef.id])
+        self.assertEqual(test_record.message_partner_ids, self.user_admin.partner_id)
+        self.assertEqual(test_record.message_channel_ids, self.env['mail.channel'])
+        self.assertEqual(test_record.message_follower_ids.subtype_ids, self.mt_mg_nodef | self.mt_al_nodef)
+
+    def test_followers_multiple_subscription_noforce(self):
+        """ Calling message_subscribe without subtypes on an existing subscription should not do anything (default < existing) """
+        test_record = self.test_record.with_user(self.user_employee)
+
+        test_record.message_subscribe(partner_ids=[self.user_admin.partner_id.id], subtype_ids=[self.mt_mg_nodef.id, self.mt_al_nodef.id])
+        self.assertEqual(test_record.message_partner_ids, self.user_admin.partner_id)
+        self.assertEqual(test_record.message_channel_ids, self.env['mail.channel'])
+        self.assertEqual(test_record.message_follower_ids.subtype_ids, self.mt_mg_nodef | self.mt_al_nodef)
+
+        # set new subtypes with force=False, meaning no rewriting of the subscription is done -> result should not change
+        test_record.message_subscribe(partner_ids=[self.user_admin.partner_id.id])
+        self.assertEqual(test_record.message_partner_ids, self.user_admin.partner_id)
+        self.assertEqual(test_record.message_channel_ids, self.env['mail.channel'])
+        self.assertEqual(test_record.message_follower_ids.subtype_ids, self.mt_mg_nodef | self.mt_al_nodef)
+
+    def test_followers_multiple_subscription_update(self):
+        """ Calling message_subscribe with subtypes on an existing subscription should replace them (new > existing) """
+        test_record = self.test_record.with_user(self.user_employee)
+        test_record.message_subscribe(partner_ids=[self.user_employee.partner_id.id], subtype_ids=[self.mt_mg_def.id, self.mt_cl_def.id])
+        self.assertEqual(test_record.message_partner_ids, self.user_employee.partner_id)
+        follower = self.env['mail.followers'].search([
+            ('res_model', '=', 'mail.test.simple'),
+            ('res_id', '=', test_record.id),
+            ('partner_id', '=', self.user_employee.partner_id.id)])
+        self.assertEqual(follower, test_record.message_follower_ids)
+        self.assertEqual(follower.subtype_ids, self.mt_mg_def | self.mt_cl_def)
+
+        # remove one subtype `mt_mg_def` and set new subtype `mt_al_def`
+        test_record.message_subscribe(partner_ids=[self.user_employee.partner_id.id], subtype_ids=[self.mt_cl_def.id, self.mt_al_def.id])
+        self.assertEqual(follower.subtype_ids, self.mt_cl_def | self.mt_al_def)
+
+    def test_followers_no_DID(self):
+        """Test that a follower cannot suffer from dissociative identity disorder.
+           It cannot be both a partner and a channel.
+        """
+        with self.assertRaises(IntegrityError), mute_logger('odoo.sql_db'):
+            self.env['mail.followers'].create({
+                'res_model': self.test_record._name,
+                'res_id': self.test_record.id,
+                'partner_id': self.user_employee.partner_id.id,
+                'channel_id': self.channel_listen.id,
+            })
+
+    def test_followers_default_partner_context(self):
+        """Test that a follower partner_id is not taken from context
+           when channel id is also defined.
+        """
+        test_record = self.test_record.with_user(self.user_employee)
+        test_record.with_context(default_partner_id=1).message_subscribe(
+            partner_ids=[self.user_employee.partner_id.id, self.user_admin.partner_id.id],
+            channel_ids=[self.channel_listen.id]
+        )
+
+    @users('employee')
+    def test_followers_inactive(self):
+        """ Test standard API does not subscribe inactive partners """
+        customer = self.env['res.partner'].create({
+            'name': 'Valid Lelitre',
+            'email': 'valid.lelitre@agrolait.com',
+            'country_id': self.env.ref('base.be').id,
+            'mobile': '0456001122',
+            'active': False,
+        })
+        document = self.env['mail.test.simple'].browse(self.test_record.id)
+        self.assertEqual(document.message_partner_ids, self.env['res.partner'])
+        document.message_subscribe(partner_ids=(self.partner_portal | customer).ids)
+        self.assertEqual(document.message_partner_ids, self.partner_portal)
+        self.assertEqual(document.message_follower_ids.partner_id, self.partner_portal)
+
+        # works through low-level API
+        document._message_subscribe(partner_ids=(self.partner_portal | customer).ids)
+        self.assertEqual(document.message_partner_ids, self.partner_portal, 'No active test: customer not visible')
+        self.assertEqual(document.message_follower_ids.partner_id, self.partner_portal | customer)
+
+    @users('employee')
+    def test_followers_private_address(self):
+        """ Test standard API does not subscribe private addresses """
+        private_address = self.env['res.partner'].sudo().create({
+            'name': 'Private Address',
+            'type': 'private',
+        })
+        document = self.env['mail.test.simple'].browse(self.test_record.id)
+        document.message_subscribe(partner_ids=(self.partner_portal | private_address).ids)
+        self.assertEqual(document.message_follower_ids.partner_id, self.partner_portal)
+
+        # works through low-level API
+        document._message_subscribe(partner_ids=(self.partner_portal | private_address).ids)
+        self.assertEqual(document.message_follower_ids.partner_id, self.partner_portal | private_address)
+
+
+@tagged('mail_followers')
+class AdvancedFollowersTest(TestMailCommon):
+
+    @classmethod
+    def setUpClass(cls):
+        super(AdvancedFollowersTest, cls).setUpClass()
+        cls._create_portal_user()
+
+        cls.test_track = cls.env['mail.test.track'].with_user(cls.user_employee).create({
+            'name': 'Test',
+        })
+
+        Subtype = cls.env['mail.message.subtype']
+
+        # clean demo data to avoid interferences
+        Subtype.search([('res_model', 'in', ['mail.test.container', 'mail.test.track'])]).unlink()
+
+        # mail.test.track subtypes (aka: task records)
+        cls.sub_track_1 = Subtype.create({
+            'name': 'Track (with child relation) 1', 'default': False,
+            'res_model': 'mail.test.track'
+        })
+        cls.sub_track_2 = Subtype.create({
+            'name': 'Track (with child relation) 2', 'default': False,
+            'res_model': 'mail.test.track'
+        })
+        cls.sub_track_nodef = Subtype.create({
+            'name': 'Generic Track subtype', 'default': False, 'internal': False,
+            'res_model': 'mail.test.track'
+        })
+        cls.sub_track_def = Subtype.create({
+            'name': 'Default track subtype', 'default': True, 'internal': False,
+            'res_model': 'mail.test.track'
+        })
+
+        # mail.test.container subtypes (aka: project records)
+        cls.umb_nodef = Subtype.create({
+            'name': 'Container NoDefault', 'default': False,
+            'res_model': 'mail.test.container'
+        })
+        cls.umb_def = Subtype.create({
+            'name': 'Container Default', 'default': True,
+            'res_model': 'mail.test.container'
+        })
+        cls.umb_def_int = Subtype.create({
+            'name': 'Container Default', 'default': True, 'internal': True,
+            'res_model': 'mail.test.container'
+        })
+        # -> subtypes for auto subscription from container to sub records
+        cls.umb_autosub_def = Subtype.create({
+            'name': 'Container AutoSub (default)', 'default': True, 'res_model': 'mail.test.container',
+            'parent_id': cls.sub_track_1.id, 'relation_field': 'container_id'
+        })
+        cls.umb_autosub_nodef = Subtype.create({
+            'name': 'Container AutoSub 2', 'default': False, 'res_model': 'mail.test.container',
+            'parent_id': cls.sub_track_2.id, 'relation_field': 'container_id'
+        })
+
+        # generic subtypes
+        cls.sub_comment = cls.env.ref('mail.mt_comment')
+        cls.sub_generic_int_nodef = Subtype.create({
+            'name': 'Generic internal subtype',
+            'default': False,
+            'internal': True,
+        })
+        cls.sub_generic_int_def = Subtype.create({
+            'name': 'Generic internal subtype (default)',
+            'default': True,
+            'internal': True,
+        })
+
+    def test_auto_subscribe_create(self):
+        """ Creator of records are automatically added as followers """
+        self.assertEqual(self.test_track.message_partner_ids, self.user_employee.partner_id)
+
+    def test_auto_subscribe_inactive(self):
+        """ Test inactive are not added as followers in automated subscription """
+        self.test_track.user_id = False
+        self.user_admin.active = False
+        self.user_admin.flush()
+        self.partner_admin.active = False
+        self.partner_admin.flush()
+
+        self.test_track.with_user(self.user_admin).message_post(body='Coucou hibou', message_type='comment')
+        self.assertEqual(self.test_track.message_partner_ids, self.user_employee.partner_id)
+        self.assertEqual(self.test_track.message_follower_ids.partner_id, self.user_employee.partner_id)
+
+        self.test_track.write({'user_id': self.user_admin.id})
+        self.assertEqual(self.test_track.message_partner_ids, self.user_employee.partner_id)
+        self.assertEqual(self.test_track.message_follower_ids.partner_id, self.user_employee.partner_id)
+
+    def test_auto_subscribe_post(self):
+        """ People posting a message are automatically added as followers """
+        self.test_track.with_user(self.user_admin).message_post(body='Coucou hibou', message_type='comment')
+        self.assertEqual(self.test_track.message_partner_ids, self.user_employee.partner_id | self.user_admin.partner_id)
+
+    def test_auto_subscribe_post_email(self):
+        """ People posting an email are automatically added as followers """
+        self.test_track.with_user(self.user_admin).message_post(body='Coucou hibou', message_type='email')
+        self.assertEqual(self.test_track.message_partner_ids, self.user_employee.partner_id | self.user_admin.partner_id)
+
+    def test_auto_subscribe_not_on_notification(self):
+        """ People posting an automatic notification are not subscribed """
+        self.test_track.with_user(self.user_admin).message_post(body='Coucou hibou', message_type='notification')
+        self.assertEqual(self.test_track.message_partner_ids, self.user_employee.partner_id)
+
+    def test_auto_subscribe_responsible(self):
+        """ Responsibles are tracked and added as followers """
+        sub = self.env['mail.test.track'].with_user(self.user_employee).create({
+            'name': 'Test',
+            'user_id': self.user_admin.id,
+        })
+        self.assertEqual(sub.message_partner_ids, (self.user_employee.partner_id | self.user_admin.partner_id))
+
+    def test_auto_subscribe_defaults(self):
+        """ Test auto subscription based on an container record. This mimics
+        the behavior of addons like project and task where subscribing to
+        some project's subtypes automatically subscribe the follower to its tasks.
+
+        Functional rules applied here
+
+         * subscribing to an container subtype with parent_id / relation_field set
+           automatically create subscription with matching subtypes
+         * subscribing to a sub-record as creator applies default subtype values
+         * portal user should not have access to internal subtypes
+
+        Inactive partners should not be auto subscribed.
+        """
+        container = self.env['mail.test.container'].with_context(self._test_context).create({
+            'name': 'Project-Like',
+        })
+
+        # have an inactive partner to check auto subscribe does not subscribe it
+        user_root = self.env.ref('base.user_root')
+        self.assertFalse(user_root.active)
+        self.assertFalse(user_root.partner_id.active)
+
+        container.message_subscribe(partner_ids=(self.partner_portal | user_root.partner_id).ids)
+        container.message_subscribe(partner_ids=self.partner_admin.ids, subtype_ids=(self.sub_comment | self.umb_autosub_nodef | self.sub_generic_int_nodef).ids)
+        self.assertEqual(container.message_partner_ids, self.partner_portal | self.partner_admin)
+        follower_por = container.message_follower_ids.filtered(lambda f: f.partner_id == self.partner_portal)
+        follower_adm = container.message_follower_ids.filtered(lambda f: f.partner_id == self.partner_admin)
+        self.assertEqual(
+            follower_por.subtype_ids,
+            self.sub_comment | self.umb_def | self.umb_autosub_def,
+            'Subscribe: Default subtypes: comment (default generic) and two model-related defaults')
+        self.assertEqual(
+            follower_adm.subtype_ids,
+            self.sub_comment | self.umb_autosub_nodef | self.sub_generic_int_nodef,
+            'Subscribe: Asked subtypes when subscribing')
+
+        sub1 = self.env['mail.test.track'].with_user(self.user_employee).create({
+            'name': 'Task-Like Test',
+            'container_id': container.id,
+        })
+
+        self.assertEqual(
+            sub1.message_partner_ids, self.partner_portal | self.partner_admin | self.user_employee.partner_id,
+            'Followers: creator (employee) + auto subscribe from parent (portal)')
+        follower_por = sub1.message_follower_ids.filtered(lambda fol: fol.partner_id == self.partner_portal)
+        follower_adm = sub1.message_follower_ids.filtered(lambda fol: fol.partner_id == self.partner_admin)
+        follower_emp = sub1.message_follower_ids.filtered(lambda fol: fol.partner_id == self.user_employee.partner_id)
+        self.assertEqual(
+            follower_por.subtype_ids, self.sub_comment | self.sub_track_1,
+            'AutoSubscribe: comment (generic checked), Track (with child relation) 1 as Umbrella AutoSub (default) was checked'
+        )
+        self.assertEqual(
+            follower_adm.subtype_ids, self.sub_comment | self.sub_track_2 | self.sub_generic_int_nodef,
+            'AutoSubscribe: comment (generic checked), Track (with child relation) 2) as Umbrella AutoSub 2 was checked, Generic internal subtype (generic checked)'
+        )
+        self.assertEqual(
+            follower_emp.subtype_ids, self.sub_comment | self.sub_track_def | self.sub_generic_int_def,
+            'AutoSubscribe: only default one as no subscription on parent'
+        )
+
+        # check portal generic subscribe
+        sub1.message_unsubscribe(partner_ids=self.partner_portal.ids)
+        sub1.message_subscribe(partner_ids=self.partner_portal.ids)
+        follower_por = sub1.message_follower_ids.filtered(lambda fol: fol.partner_id == self.partner_portal)
+
+        self.assertEqual(
+            follower_por.subtype_ids, self.sub_comment | self.sub_track_def,
+            'AutoSubscribe: only default one as no subscription on parent (no internal as portal)'
+        )
+
+        # check auto subscribe as creator + auto subscribe as parent follower takes both subtypes
+        container.message_subscribe(
+            partner_ids=self.user_employee.partner_id.ids,
+            subtype_ids=(self.sub_comment | self.sub_generic_int_nodef | self.umb_autosub_nodef).ids)
+        sub2 = self.env['mail.test.track'].with_user(self.user_employee).create({
+            'name': 'Task-Like Test',
+            'container_id': container.id,
+        })
+        follower_emp = sub2.message_follower_ids.filtered(lambda fol: fol.partner_id == self.user_employee.partner_id)
+        defaults = self.sub_comment | self.sub_track_def | self.sub_generic_int_def
+        parents = self.sub_generic_int_nodef | self.sub_track_2
+        self.assertEqual(
+            follower_emp.subtype_ids, defaults + parents,
+            'AutoSubscribe: at create auto subscribe as creator + from parent take both subtypes'
+        )
+
+
+class AdvancedResponsibleNotifiedTest(TestMailCommon):
+    def setUp(self):
+        super(AdvancedResponsibleNotifiedTest, self).setUp()
+
+        # patch registry to simulate a ready environment so that _message_auto_subscribe_notify
+        # will be executed with the associated notification
+        old = self.env.registry.ready
+        self.env.registry.ready = True
+        self.addCleanup(setattr, self.env.registry, 'ready', old)
+
+    def test_auto_subscribe_notify_email(self):
+        """ Responsible is notified when assigned """
+        partner = self.env['res.partner'].create({"name": "demo1", "email": "demo1@test.com"})
+        notified_user = self.env['res.users'].create({
+            'login': 'demo1',
+            'partner_id': partner.id,
+            'notification_type': 'email',
+        })
+
+        # TODO master: add a 'state' selection field on 'mail.test.track' with a 'done' value to have a complete test
+        # check that 'default_state' context does not collide with mail.mail default values
+        sub = self.env['mail.test.track'].with_user(self.user_employee).with_context({
+            'default_state': 'done',
+            'mail_notify_force_send': False
+        }).create({
+            'name': 'Test',
+            'user_id': notified_user.id,
+        })
+
+        self.assertEqual(sub.message_partner_ids, (self.user_employee.partner_id | notified_user.partner_id))
+        # fetch created "You have been assigned to 'Test'" mail.message
+        mail_message = self.env['mail.message'].search([
+            ('model', '=', 'mail.test.track'),
+            ('res_id', '=', sub.id),
+            ('partner_ids', 'in', partner.id),
+        ])
+        self.assertEqual(1, len(mail_message))
+
+        # verify that a mail.mail is attached to it with the correct state ('outgoing')
+        mail_notification = mail_message.notification_ids
+        self.assertEqual(1, len(mail_notification))
+        self.assertTrue(bool(mail_notification.mail_id))
+        self.assertEqual('outgoing', mail_notification.mail_id.state)
+
+
+@tagged('post_install', '-at_install')
+class DuplicateNotificationTest(TestMailCommon):
+    def test_no_duplicate_notification(self):
+        """
+        Check that we only create one mail.notification per partner
+
+        Post install because we need the registery to be ready to send notification
+        """
+        #Simulate case of 2 users that got their partner merged
+        common_partner = self.env['res.partner'].create({"name": "demo1", "email": "demo1@test.com"})
+        user_1 = self.env['res.users'].create({'login': 'demo1', 'partner_id': common_partner.id, 'notification_type': 'email'})
+        user_2 = self.env['res.users'].create({'login': 'demo2', 'partner_id': common_partner.id, 'notification_type': 'inbox'})
+
+        #Trigger auto subscribe notification
+        test = self.env['mail.test.track'].create({"name": "Test Track", "user_id": user_2.id})
+        mail_message = self.env['mail.message'].search([
+             ('res_id', '=', test.id),
+             ('model', '=', 'mail.test.track'),
+             ('message_type', '=', 'user_notification')
+        ])
+        notif = self.env['mail.notification'].search([
+            ('mail_message_id', '=', mail_message.id),
+            ('res_partner_id', '=', common_partner.id)
+        ])
+        self.assertEqual(len(notif), 1)
+        self.assertEqual(notif.notification_type, 'email')
+
+        subtype = self.env.ref('mail.mt_comment')
+        res = self.env['mail.followers']._get_recipient_data(test, 'comment',  subtype.id, pids=common_partner.ids)
+        partner_notif = [r for r in res if r[0] == common_partner.id]
+        self.assertEqual(len(partner_notif), 1)
+        self.assertEqual(partner_notif[0][5], 'email')
+
+@tagged('post_install', '-at_install')
+class UnlinkedNotificationTest(TestMailCommon):
+    def test_unlinked_notification(self):
+        """
+        Check that we unlink the created user_notification after unlinked the related document
+
+        Post install because we need the registery to be ready to send notification
+        """
+        common_partner = self.env['res.partner'].create({"name": "demo1", "email": "demo1@test.com"})
+        user_1 = self.env['res.users'].create({'login': 'demo1', 'partner_id': common_partner.id, 'notification_type': 'inbox'})
+
+        test = self.env['mail.test.track'].create({"name": "Test Track", "user_id": user_1.id})
+        test_id = test.id
+        mail_message = self.env['mail.message'].search([
+             ('res_id', '=', test_id),
+             ('model', '=', 'mail.test.track'),
+             ('message_type', '=', 'user_notification')
+        ])
+        self.assertEqual(len(mail_message), 1)
+        test.unlink()
+        mail_message = self.env['mail.message'].search([
+             ('res_id', '=', test_id),
+             ('model', '=', 'mail.test.track'),
+             ('message_type', '=', 'user_notification')
+        ])
+        self.assertEqual(len(mail_message), 0)
diff --git a/addons/test_mail/tests/test_mail_gateway.py b/addons/test_mail/tests/test_mail_gateway.py
new file mode 100644
index 00000000..ea0ef7c6
--- /dev/null
+++ b/addons/test_mail/tests/test_mail_gateway.py
@@ -0,0 +1,1273 @@
+# -*- coding: utf-8 -*-
+# Part of Odoo. See LICENSE file for full copyright and licensing details.
+
+import socket
+
+from unittest.mock import DEFAULT
+from unittest.mock import patch
+
+from odoo import exceptions
+from odoo.addons.mail.tests.common import mail_new_test_user
+from odoo.addons.test_mail.data import test_mail_data
+from odoo.addons.test_mail.data.test_mail_data import MAIL_TEMPLATE
+from odoo.addons.test_mail.models.test_mail_models import MailTestGateway
+from odoo.addons.test_mail.tests.common import TestMailCommon
+from odoo.tests import tagged
+from odoo.tests.common import users
+from odoo.tools import email_split_and_format, formataddr, mute_logger
+
+
+@tagged('mail_gateway')
+class TestEmailParsing(TestMailCommon):
+
+    def test_message_parse_body(self):
+        # test pure plaintext
+        plaintext = self.format(test_mail_data.MAIL_TEMPLATE_PLAINTEXT, email_from='"Sylvie Lelitre" <test.sylvie.lelitre@agrolait.com>')
+        res = self.env['mail.thread'].message_parse(self.from_string(plaintext))
+        self.assertIn('Please call me as soon as possible this afternoon!', res['body'])
+
+        # test multipart / text and html -> html has priority
+        multipart = self.format(MAIL_TEMPLATE, email_from='"Sylvie Lelitre" <test.sylvie.lelitre@agrolait.com>')
+        res = self.env['mail.thread'].message_parse(self.from_string(multipart))
+        self.assertIn('<p>Please call me as soon as possible this afternoon!</p>', res['body'])
+
+        # test multipart / mixed
+        res = self.env['mail.thread'].message_parse(self.from_string(test_mail_data.MAIL_MULTIPART_MIXED))
+        self.assertNotIn(
+            'Should create a multipart/mixed: from gmail, *bold*, with attachment', res['body'],
+            'message_parse: text version should not be in body after parsing multipart/mixed')
+        self.assertIn(
+            '<div dir="ltr">Should create a multipart/mixed: from gmail, <b>bold</b>, with attachment.<br clear="all"><div><br></div>', res['body'],
+            'message_parse: html version should be in body after parsing multipart/mixed')
+
+        res = self.env['mail.thread'].message_parse(self.from_string(test_mail_data.MAIL_MULTIPART_MIXED_TWO))
+        self.assertNotIn('First and second part', res['body'],
+                         'message_parse: text version should not be in body after parsing multipart/mixed')
+        self.assertIn('First part', res['body'],
+                      'message_parse: first part of the html version should be in body after parsing multipart/mixed')
+        self.assertIn('Second part', res['body'],
+                      'message_parse: second part of the html version should be in body after parsing multipart/mixed')
+
+        res = self.env['mail.thread'].message_parse(self.from_string(test_mail_data.MAIL_SINGLE_BINARY))
+        self.assertEqual(res['body'], '')
+        self.assertEqual(res['attachments'][0][0], 'thetruth.pdf')
+
+        res = self.env['mail.thread'].message_parse(self.from_string(test_mail_data.MAIL_MULTIPART_WEIRD_FILENAME))
+        self.assertEqual(res['attachments'][0][0], '62_@;,][)=.(ÇÀÉ.txt')
+
+    def test_message_parse_eml(self):
+        # Test that the parsing of mail with embedded emails as eml(msg) which generates empty attachments, can be processed.
+        mail = self.format(test_mail_data.MAIL_EML_ATTACHMENT, email_from='"Sylvie Lelitre" <test.sylvie.lelitre@agrolait.com>', to='generic@test.com')
+        self.env['mail.thread'].message_parse(self.from_string(mail))
+
+    def test_message_parse_eml_bounce_headers(self):
+        # Test Text/RFC822-Headers MIME content-type
+        msg_id = '<861878175823148.1577183525.736005783081055-openerp-19177-account.invoice@mycompany.example.com>'
+        mail = self.format(
+            test_mail_data.MAIL_EML_ATTACHMENT_BOUNCE_HEADERS,
+            email_from='MAILER-DAEMON@example.com (Mail Delivery System)',
+            to='test_bounce+82240-account.invoice-19177@mycompany.example.com',
+            # msg_id goes to the attachment's Message-Id header
+            msg_id=msg_id,
+        )
+        res = self.env['mail.thread'].message_parse(self.from_string(mail))
+
+        self.assertEqual(res['bounced_msg_id'], [msg_id], "Message-Id is not extracted from Text/RFC822-Headers attachment")
+
+    def test_message_parse_plaintext(self):
+        """ Incoming email in plaintext should be stored as html """
+        mail = self.format(test_mail_data.MAIL_TEMPLATE_PLAINTEXT, email_from='"Sylvie Lelitre" <test.sylvie.lelitre@agrolait.com>', to='generic@test.com')
+        res = self.env['mail.thread'].message_parse(self.from_string(mail))
+        self.assertIn('<pre>\nPlease call me as soon as possible this afternoon!\n\n--\nSylvie\n</pre>', res['body'])
+
+    def test_message_parse_xhtml(self):
+        # Test that the parsing of XHTML mails does not fail
+        self.env['mail.thread'].message_parse(self.from_string(test_mail_data.MAIL_XHTML))
+
+
+@tagged('mail_gateway')
+class TestMailAlias(TestMailCommon):
+
+    @users('employee')
+    def test_alias_creation(self):
+        record = self.env['mail.test.container'].create({
+            'name': 'Test Record',
+            'alias_name': 'alias.test',
+            'alias_contact': 'followers',
+        })
+        self.assertEqual(record.alias_id.alias_model_id, self.env['ir.model']._get('mail.test.container'))
+        self.assertEqual(record.alias_id.alias_force_thread_id, record.id)
+        self.assertEqual(record.alias_id.alias_parent_model_id, self.env['ir.model']._get('mail.test.container'))
+        self.assertEqual(record.alias_id.alias_parent_thread_id, record.id)
+        self.assertEqual(record.alias_id.alias_name, 'alias.test')
+        self.assertEqual(record.alias_id.alias_contact, 'followers')
+
+        record.write({
+            'alias_name': 'better.alias.test',
+            'alias_defaults': "{'default_name': 'defaults'}"
+        })
+        self.assertEqual(record.alias_id.alias_name, 'better.alias.test')
+        self.assertEqual(record.alias_id.alias_defaults, "{'default_name': 'defaults'}")
+
+        with self.assertRaises(exceptions.AccessError):
+            record.write({
+                'alias_force_thread_id': 0,
+            })
+
+        with self.assertRaises(exceptions.AccessError):
+            record.write({
+                'alias_model_id': self.env['ir.model']._get('mail.test.gateway').id,
+            })
+
+        with self.assertRaises(exceptions.ValidationError):
+            record.write({'alias_defaults': "{'custom_field': brokendict"})
+
+    def test_alias_setup(self):
+        alias = self.env['mail.alias'].create({
+            'alias_model_id': self.env['ir.model']._get('mail.test.container').id,
+            'alias_name': 'b4r+_#_R3wl$$',
+        })
+        self.assertEqual(alias.alias_name, 'b4r+_-_r3wl-', 'Disallowed chars should be replaced by hyphens')
+
+        with self.assertRaises(exceptions.ValidationError):
+            alias.write({'alias_defaults': "{'custom_field': brokendict"})
+
+    def test_alias_name_unique(self):
+        alias_model_id = self.env['ir.model']._get('mail.test.gateway').id
+        catchall_alias = self.env['ir.config_parameter'].sudo().get_param('mail.catchall.alias')
+        bounce_alias = self.env['ir.config_parameter'].sudo().get_param('mail.bounce.alias')
+
+        # test you cannot create aliases matching bounce / catchall
+        with self.assertRaises(exceptions.UserError), self.cr.savepoint():
+            self.env['mail.alias'].create({'alias_model_id': alias_model_id, 'alias_name': catchall_alias})
+        with self.assertRaises(exceptions.UserError), self.cr.savepoint():
+            self.env['mail.alias'].create({'alias_model_id': alias_model_id, 'alias_name': bounce_alias})
+
+        new_mail_alias = self.env['mail.alias'].create({
+            'alias_model_id': alias_model_id,
+            'alias_name': 'unused.test.alias'
+        })
+
+        # test that re-using catchall and bounce alias raises UserError
+        with self.assertRaises(exceptions.UserError), self.cr.savepoint():
+            new_mail_alias.write({
+                'alias_name': catchall_alias
+            })
+        with self.assertRaises(exceptions.UserError), self.cr.savepoint():
+            new_mail_alias.write({
+                'alias_name': bounce_alias
+            })
+
+        new_mail_alias.write({'alias_name': 'another.unused.test.alias'})
+
+        # test that duplicating an alias should have blank name
+        copy_new_mail_alias = new_mail_alias.copy()
+        self.assertFalse(copy_new_mail_alias.alias_name)
+
+        # cannot set catchall / bounce to used alias
+        with self.assertRaises(exceptions.UserError), self.cr.savepoint():
+            self.env['ir.config_parameter'].sudo().set_param('mail.catchall.alias', new_mail_alias.alias_name)
+        with self.assertRaises(exceptions.UserError), self.cr.savepoint():
+            self.env['ir.config_parameter'].sudo().set_param('mail.bounce.alias', new_mail_alias.alias_name)
+
+    def test_alias_mixin_copy(self):
+        user_demo = self.env.ref('base.user_demo')
+        self.assertFalse(user_demo.has_group('base.group_system'), 'Demo user is not supposed to have Administrator access')
+        self._test_alias_mixin_copy(user_demo, 'alias.test1', False)
+        self._test_alias_mixin_copy(user_demo, 'alias.test2', '<p>What Is Dead May Never Die</p>')
+
+    def _test_alias_mixin_copy(self, user, alias_name, alias_bounced_content):
+        record = self.env['mail.test.container'].with_user(user).with_context(lang='en_US').create({
+            'name': 'Test Record',
+            'alias_name': alias_name,
+            'alias_contact': 'followers',
+            'alias_bounced_content': alias_bounced_content,
+        })
+        self.assertEqual(record.alias_bounced_content, alias_bounced_content)
+        record_copy = record.copy()
+        self.assertEqual(record_copy.alias_bounced_content, alias_bounced_content)
+
+
+@tagged('mail_gateway')
+class TestMailgateway(TestMailCommon):
+
+    @classmethod
+    def setUpClass(cls):
+        super(TestMailgateway, cls).setUpClass()
+        cls.test_model = cls.env['ir.model']._get('mail.test.gateway')
+        cls.email_from = '"Sylvie Lelitre" <test.sylvie.lelitre@agrolait.com>'
+
+        cls.test_record = cls.env['mail.test.gateway'].with_context(cls._test_context).create({
+            'name': 'Test',
+            'email_from': 'ignasse@example.com',
+        }).with_context({})
+
+        cls.partner_1 = cls.env['res.partner'].with_context(cls._test_context).create({
+            'name': 'Valid Lelitre',
+            'email': 'valid.lelitre@agrolait.com',
+        })
+        # groups@.. will cause the creation of new mail.test.gateway
+        cls.alias = cls.env['mail.alias'].create({
+            'alias_name': 'groups',
+            'alias_user_id': False,
+            'alias_model_id': cls.test_model.id,
+            'alias_contact': 'everyone'})
+
+        # Set a first message on public group to test update and hierarchy
+        cls.fake_email = cls.env['mail.message'].create({
+            'model': 'mail.test.gateway',
+            'res_id': cls.test_record.id,
+            'subject': 'Public Discussion',
+            'message_type': 'email',
+            'subtype_id': cls.env.ref('mail.mt_comment').id,
+            'author_id': cls.partner_1.id,
+            'message_id': '<123456-openerp-%s-mail.test.gateway@%s>' % (cls.test_record.id, socket.gethostname()),
+        })
+
+        cls._init_mail_gateway()
+
+    # --------------------------------------------------
+    # Base low-level tests
+    # --------------------------------------------------
+
+    @mute_logger('odoo.addons.mail.models.mail_thread', 'odoo.models')
+    def test_message_process_alias_basic(self):
+        """ Test details of created message going through mailgateway """
+        record = self.format_and_process(MAIL_TEMPLATE, self.email_from, 'groups@test.com', subject='Specific')
+
+        # Test: one group created by mailgateway administrator as user_id is not set
+        self.assertEqual(len(record), 1, 'message_process: a new mail.test should have been created')
+        res = record.get_metadata()[0].get('create_uid') or [None]
+        self.assertEqual(res[0], self.env.uid)
+
+        # Test: one message that is the incoming email
+        self.assertEqual(len(record.message_ids), 1)
+        msg = record.message_ids[0]
+        self.assertEqual(msg.subject, 'Specific')
+        self.assertIn('Please call me as soon as possible this afternoon!', msg.body)
+        self.assertEqual(msg.message_type, 'email')
+        self.assertEqual(msg.subtype_id, self.env.ref('mail.mt_comment'))
+
+    @mute_logger('odoo.addons.mail.models.mail_thread')
+    def test_message_process_cid(self):
+        record = self.format_and_process(test_mail_data.MAIL_MULTIPART_IMAGE, self.email_from, 'groups@test.com')
+        message = record.message_ids[0]
+        for attachment in message.attachment_ids:
+            self.assertIn('/web/image/%s' % attachment.id, message.body)
+        self.assertEqual(
+            set(message.attachment_ids.mapped('name')),
+            set(['rosaçée.gif', 'verte!µ.gif', 'orangée.gif']))
+
+    @mute_logger('odoo.addons.mail.models.mail_thread')
+    def test_message_process_followers(self):
+        """ Incoming email: recognized author not archived and not odoobot: added as follower """
+        with self.mock_mail_gateway():
+            record = self.format_and_process(MAIL_TEMPLATE, self.partner_1.email_formatted, 'groups@test.com')
+
+        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, self.partner_1.email_formatted)
+        self.assertEqual(record.message_follower_ids.partner_id, self.partner_1,
+                         'message_process: recognized email -> added as follower')
+        self.assertEqual(record.message_partner_ids, self.partner_1,
+                         'message_process: recognized email -> added as follower')
+
+        # just an email -> no follower
+        with self.mock_mail_gateway():
+            record2 = self.format_and_process(
+                MAIL_TEMPLATE, self.email_from, 'groups@test.com',
+                subject='Another Email')
+
+        self.assertEqual(record2.message_ids[0].author_id, self.env['res.partner'])
+        self.assertEqual(record2.message_ids[0].email_from, self.email_from)
+        self.assertEqual(record2.message_follower_ids.partner_id, self.env['res.partner'],
+                         'message_process: unrecognized email -> no follower')
+        self.assertEqual(record2.message_partner_ids, self.env['res.partner'],
+                         'message_process: unrecognized email -> no follower')
+
+        # archived partner -> no follower
+        self.partner_1.active = False
+        self.partner_1.flush()
+        with self.mock_mail_gateway():
+            record3 = self.format_and_process(
+                MAIL_TEMPLATE, self.partner_1.email_formatted, 'groups@test.com',
+                subject='Yet Another Email')
+
+        self.assertEqual(record3.message_ids[0].author_id, self.env['res.partner'])
+        self.assertEqual(record3.message_ids[0].email_from, self.partner_1.email_formatted)
+        self.assertEqual(record3.message_follower_ids.partner_id, self.env['res.partner'],
+                         'message_process: unrecognized email -> no follower')
+        self.assertEqual(record3.message_partner_ids, self.env['res.partner'],
+                         'message_process: unrecognized email -> no follower')
+
+
+        # partner_root -> never again
+        odoobot = self.env.ref('base.partner_root')
+        odoobot.active = True
+        odoobot.email = 'odoobot@example.com'
+        with self.mock_mail_gateway():
+            record4 = self.format_and_process(
+                MAIL_TEMPLATE, odoobot.email_formatted, 'groups@test.com',
+                subject='Odoobot Automatic Answer')
+
+        self.assertEqual(record4.message_ids[0].author_id, odoobot)
+        self.assertEqual(record4.message_ids[0].email_from, odoobot.email_formatted)
+        self.assertEqual(record4.message_follower_ids.partner_id, self.env['res.partner'],
+                         'message_process: unrecognized email -> no follower')
+        self.assertEqual(record4.message_partner_ids, self.env['res.partner'],
+                         'message_process: unrecognized email -> no follower')
+
+    # --------------------------------------------------
+    # Author recognition
+    # --------------------------------------------------
+
+    @mute_logger('odoo.addons.mail.models.mail_thread', 'odoo.models')
+    def test_message_process_email_email_from(self):
+        """ Incoming email: not recognized author: email_from, no author_id, no followers """
+        record = self.format_and_process(MAIL_TEMPLATE, self.email_from, 'groups@test.com')
+        self.assertFalse(record.message_ids[0].author_id, 'message_process: unrecognized email -> no author_id')
+        self.assertEqual(record.message_ids[0].email_from, self.email_from)
+        self.assertEqual(len(record.message_partner_ids), 0,
+                         'message_process: newly create group should not have any follower')
+
+    @mute_logger('odoo.addons.mail.models.mail_thread', 'odoo.models')
+    def test_message_process_email_author(self):
+        """ Incoming email: recognized author: email_from, author_id, added as follower """
+        with self.mock_mail_gateway():
+            record = self.format_and_process(MAIL_TEMPLATE, self.partner_1.email_formatted, 'groups@test.com', subject='Test1')
+
+        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, self.partner_1.email_formatted)
+        self.assertNotSentEmail()  # No notification / bounce should be sent
+
+        # Email recognized if partner has a formatted email
+        self.partner_1.write({'email': '"Valid Lelitre" <%s>' % self.partner_1.email})
+        record = self.format_and_process(MAIL_TEMPLATE, self.partner_1.email, 'groups@test.com', subject='Test2')
+
+        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, self.partner_1.email)
+        self.assertNotSentEmail()  # No notification / bounce should be sent
+
+    @mute_logger('odoo.addons.mail.models.mail_thread', 'odoo.models')
+    def test_message_process_email_partner_find(self):
+        """ Finding the partner based on email, based on partner / user / follower """
+        self.alias.write({'alias_force_thread_id': self.test_record.id})
+        from_1 = self.env['res.partner'].create({'name': 'Brice Denisse', 'email': 'from.test@example.com'})
+
+        self.format_and_process(MAIL_TEMPLATE, from_1.email_formatted, 'groups@test.com')
+        self.assertEqual(self.test_record.message_ids[0].author_id, from_1)
+        self.test_record.message_unsubscribe([from_1.id])
+
+        from_2 = mail_new_test_user(self.env, login='B', groups='base.group_user', name='User Denisse', email='from.test@example.com')
+
+        self.format_and_process(MAIL_TEMPLATE, from_1.email_formatted, 'groups@test.com')
+        self.assertEqual(self.test_record.message_ids[0].author_id, from_2.partner_id)
+        self.test_record.message_unsubscribe([from_2.partner_id.id])
+
+        from_3 = self.env['res.partner'].create({'name': 'FOllower Denisse', 'email': 'from.test@example.com'})
+        self.test_record.message_subscribe([from_3.id])
+
+        self.format_and_process(MAIL_TEMPLATE, from_1.email_formatted, 'groups@test.com')
+        self.assertEqual(self.test_record.message_ids[0].author_id, from_3)
+
+    @mute_logger('odoo.addons.mail.models.mail_thread', 'odoo.models')
+    def test_message_process_email_author_exclude_alias(self):
+        """ Do not set alias as author to avoid including aliases in discussions """
+        from_1 = self.env['res.partner'].create({'name': 'Brice Denisse', 'email': 'from.test@test.com'})
+        self.env['mail.alias'].create({
+            'alias_name': 'from.test',
+            'alias_model_id': self.env['ir.model']._get('mail.test.gateway').id
+        })
+
+        record = self.format_and_process(MAIL_TEMPLATE, from_1.email_formatted, 'groups@test.com')
+        self.assertFalse(record.message_ids[0].author_id)
+        self.assertEqual(record.message_ids[0].email_from, from_1.email_formatted)
+
+    # --------------------------------------------------
+    # Alias configuration
+    # --------------------------------------------------
+
+    @mute_logger('odoo.addons.mail.models.mail_thread', 'odoo.models.unlink', 'odoo.addons.mail.models.mail_mail')
+    def test_message_process_alias_config_bounced_content(self):
+        """ Custom bounced message for the alias => Received this custom message """
+        self.alias.write({
+            'alias_contact': 'partners',
+            'alias_bounced_content': '<p>What Is Dead May Never Die</p>'
+        })
+
+        # Test: custom bounced content
+        with self.mock_mail_gateway():
+            record = self.format_and_process(MAIL_TEMPLATE, self.email_from, 'groups@test.com', subject='Should Bounce')
+        self.assertFalse(record, 'message_process: should have bounced')
+        self.assertSentEmail('"MAILER-DAEMON" <bounce.test@test.com>', ['whatever-2a840@postmaster.twitter.com'], body_content='<p>What Is Dead May Never Die</p>')
+
+        self.alias.write({
+            'alias_contact': 'partners',
+            'alias_bounced_content': '<p></br></p>'
+        })
+
+        # Test: with "empty" bounced content (simulate view, putting always '<p></br></p>' in html field)
+        with self.mock_mail_gateway():
+            record = self.format_and_process(MAIL_TEMPLATE, self.email_from, 'groups@test.com', subject='Should Bounce')
+        self.assertFalse(record, 'message_process: should have bounced')
+        # Check if default (hardcoded) value is in the mail content
+        self.assertSentEmail('"MAILER-DAEMON" <bounce.test@test.com>', ['whatever-2a840@postmaster.twitter.com'], body_content='The following email sent to')
+
+    @mute_logger('odoo.addons.mail.models.mail_thread', 'odoo.addons.mail.models.mail_mail', 'odoo.models.unlink')
+    def test_message_process_alias_config_bounced_to(self):
+        """ Check bounce message contains the bouncing alias, not a generic "to" """
+        self.alias.write({'alias_contact': 'partners'})
+        bounce_message_with_alias = "The following email sent to %s cannot be accepted because this is a private email address." % self.alias.display_name.lower()
+
+        # Bounce is To
+        with self.mock_mail_gateway():
+            self.format_and_process(
+                MAIL_TEMPLATE, self.email_from, 'groups@example.com',
+                cc='other@gmail.com', subject='Should Bounce')
+        self.assertIn(bounce_message_with_alias, self._mails[0].get('body'))
+
+        # Bounce is CC
+        with self.mock_mail_gateway():
+            self.format_and_process(
+                MAIL_TEMPLATE, self.email_from, 'other@gmail.com',
+                cc='groups@example.com', subject='Should Bounce')
+        self.assertIn(bounce_message_with_alias, self._mails[0].get('body'))
+
+        # Bounce is part of To
+        with self.mock_mail_gateway():
+            self.format_and_process(
+                MAIL_TEMPLATE, self.email_from, 'other@gmail.com, groups@example.com',
+                subject='Should Bounce')
+        self.assertIn(bounce_message_with_alias, self._mails[0].get('body'))
+
+    @mute_logger('odoo.addons.mail.models.mail_thread', 'odoo.models')
+    def test_message_process_alias_defaults(self):
+        """ Test alias defaults and inner values """
+        self.alias.write({
+            'alias_user_id': self.user_employee.id,
+            'alias_defaults': "{'custom_field': 'defaults_custom'}"
+        })
+
+        record = self.format_and_process(MAIL_TEMPLATE, self.email_from, 'groups@test.com', subject='Specific')
+        self.assertEqual(len(record), 1)
+        res = record.get_metadata()[0].get('create_uid') or [None]
+        self.assertEqual(res[0], self.user_employee.id)
+        self.assertEqual(record.name, 'Specific')
+        self.assertEqual(record.custom_field, 'defaults_custom')
+
+        self.alias.write({'alias_defaults': '""'})
+        record = self.format_and_process(MAIL_TEMPLATE, self.email_from, 'groups@test.com', subject='Specific2')
+        self.assertEqual(len(record), 1)
+        res = record.get_metadata()[0].get('create_uid') or [None]
+        self.assertEqual(res[0], self.user_employee.id)
+        self.assertEqual(record.name, 'Specific2')
+        self.assertFalse(record.custom_field)
+
+    @mute_logger('odoo.addons.mail.models.mail_thread', 'odoo.models')
+    def test_message_process_alias_user_id(self):
+        """ Test alias ownership """
+        self.alias.write({'alias_user_id': self.user_employee.id})
+
+        record = self.format_and_process(MAIL_TEMPLATE, self.email_from, 'groups@test.com')
+        self.assertEqual(len(record), 1)
+        res = record.get_metadata()[0].get('create_uid') or [None]
+        self.assertEqual(res[0], self.user_employee.id)
+
+    @mute_logger('odoo.addons.mail.models.mail_thread', 'odoo.models')
+    def test_message_process_alias_everyone(self):
+        """ Incoming email: everyone: new record + message_new """
+        self.alias.write({'alias_contact': 'everyone'})
+
+        record = self.format_and_process(MAIL_TEMPLATE, self.email_from, 'groups@test.com', subject='Specific')
+        self.assertEqual(len(record), 1)
+        self.assertEqual(len(record.message_ids), 1)
+
+    @mute_logger('odoo.addons.mail.models.mail_thread', 'odoo.models.unlink', 'odoo.addons.mail.models.mail_mail')
+    def test_message_process_alias_partners_bounce(self):
+        """ Incoming email from an unknown partner on a Partners only alias -> bounce + test bounce email """
+        self.alias.write({'alias_contact': 'partners'})
+
+        # Test: no group created, email bounced
+        with self.mock_mail_gateway():
+            record = self.format_and_process(MAIL_TEMPLATE, self.email_from, 'groups@test.com', subject='Should Bounce')
+        self.assertFalse(record)
+        self.assertSentEmail('"MAILER-DAEMON" <bounce.test@test.com>', ['whatever-2a840@postmaster.twitter.com'], subject='Re: Should Bounce')
+
+    @mute_logger('odoo.addons.mail.models.mail_thread', 'odoo.models.unlink', 'odoo.addons.mail.models.mail_mail')
+    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.gateway').id,
+            'alias_parent_thread_id': self.test_record.id,
+        })
+
+        # Test: unknown on followers alias -> bounce
+        with self.mock_mail_gateway():
+            record = self.format_and_process(MAIL_TEMPLATE, self.email_from, 'groups@test.com', subject='Should Bounce')
+        self.assertFalse(record, 'message_process: should have bounced')
+        self.assertSentEmail('"MAILER-DAEMON" <bounce.test@test.com>', ['whatever-2a840@postmaster.twitter.com'], subject='Re: Should Bounce')
+
+        # Test: partner on followers alias -> bounce
+        self._init_mail_mock()
+        with self.mock_mail_gateway():
+            record = self.format_and_process(MAIL_TEMPLATE, self.partner_1.email_formatted, 'groups@test.com', subject='Should Bounce')
+        self.assertFalse(record, 'message_process: should have bounced')
+        self.assertSentEmail('"MAILER-DAEMON" <bounce.test@test.com>', ['whatever-2a840@postmaster.twitter.com'], subject='Re: Should Bounce')
+
+    @mute_logger('odoo.addons.mail.models.mail_thread', 'odoo.models')
+    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, self.partner_1.email_formatted, 'groups@test.com')
+
+        # Test: one group created by alias user
+        self.assertEqual(len(record), 1)
+        self.assertEqual(len(record.message_ids), 1)
+
+    @mute_logger('odoo.addons.mail.models.mail_thread', 'odoo.models')
+    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.gateway').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, self.partner_1.email_formatted, 'groups@test.com')
+
+        # Test: one group created by Raoul (or Sylvie maybe, if we implement it)
+        self.assertEqual(len(record), 1)
+
+    @mute_logger('odoo.addons.mail.models.mail_thread', 'odoo.models.unlink', 'odoo.addons.mail.models.mail_mail')
+    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])
+        with self.mock_mail_gateway():
+            record = self.format_and_process(
+                MAIL_TEMPLATE, self.email_from, 'groups@test.com>',
+                msg_id='<1198923581.41972151344608186799.JavaMail.diff1@agrolait.com>', subject='Re: cats')
+
+        # Test: no new group + new message
+        self.assertFalse(record, '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.assertSentEmail(self.email_from, [self.partner_1], subject='Re: cats')
+
+    # --------------------------------------------------
+    # Creator recognition
+    # --------------------------------------------------
+
+    @mute_logger('odoo.addons.mail.models.mail_thread')
+    def test_message_process_create_uid_crash(self):
+        def _employee_crash(*args, **kwargs):
+            """ If employee is test employee, consider he has no access on document """
+            recordset = args[0]
+            if recordset.env.uid == self.user_employee.id and not recordset.env.su:
+                if kwargs.get('raise_exception', True):
+                    raise exceptions.AccessError('Hop hop hop Ernest, please step back.')
+                return False
+            return DEFAULT
+
+        with patch.object(MailTestGateway, 'check_access_rights', autospec=True, side_effect=_employee_crash):
+            record = self.format_and_process(MAIL_TEMPLATE, self.user_employee.email_formatted, 'groups@test.com', subject='NoEmployeeAllowed')
+        self.assertEqual(record.create_uid, self.user_employee)
+        self.assertEqual(record.message_ids[0].subject, 'NoEmployeeAllowed')
+        self.assertEqual(record.message_ids[0].create_uid, self.user_employee)
+        self.assertEqual(record.message_ids[0].author_id, self.user_employee.partner_id)
+
+    @mute_logger('odoo.addons.mail.models.mail_thread')
+    def test_message_process_create_uid_email(self):
+        record = self.format_and_process(MAIL_TEMPLATE, self.user_employee.email_formatted, 'groups@test.com', subject='Email Found')
+        self.assertEqual(record.create_uid, self.user_employee)
+        self.assertEqual(record.message_ids[0].subject, 'Email Found')
+        self.assertEqual(record.message_ids[0].create_uid, self.user_employee)
+        self.assertEqual(record.message_ids[0].author_id, self.user_employee.partner_id)
+
+        record = self.format_and_process(MAIL_TEMPLATE, 'Another name <%s>' % self.user_employee.email, 'groups@test.com', subject='Email OtherName')
+        self.assertEqual(record.create_uid, self.user_employee)
+        self.assertEqual(record.message_ids[0].subject, 'Email OtherName')
+        self.assertEqual(record.message_ids[0].create_uid, self.user_employee)
+        self.assertEqual(record.message_ids[0].author_id, self.user_employee.partner_id)
+
+        record = self.format_and_process(MAIL_TEMPLATE, self.user_employee.email_normalized, 'groups@test.com', subject='Email SimpleEmail')
+        self.assertEqual(record.create_uid, self.user_employee)
+        self.assertEqual(record.message_ids[0].subject, 'Email SimpleEmail')
+        self.assertEqual(record.message_ids[0].create_uid, self.user_employee)
+        self.assertEqual(record.message_ids[0].author_id, self.user_employee.partner_id)
+
+    @mute_logger('odoo.addons.mail.models.mail_thread')
+    def test_message_process_create_uid_email_follower(self):
+        self.alias.write({
+            'alias_parent_model_id': self.test_model.id,
+            'alias_parent_thread_id': self.test_record.id,
+        })
+        follower_user = mail_new_test_user(self.env, login='better', groups='base.group_user', name='Ernest Follower', email=self.user_employee.email)
+        self.test_record.message_subscribe(follower_user.partner_id.ids)
+
+        record = self.format_and_process(MAIL_TEMPLATE, self.user_employee.email_formatted, 'groups@test.com', subject='FollowerWinner')
+        self.assertEqual(record.create_uid, follower_user)
+        self.assertEqual(record.message_ids[0].subject, 'FollowerWinner')
+        self.assertEqual(record.message_ids[0].create_uid, follower_user)
+        self.assertEqual(record.message_ids[0].author_id, follower_user.partner_id)
+
+        # name order win
+        self.test_record.message_unsubscribe(follower_user.partner_id.ids)
+        self.test_record.flush()
+        record = self.format_and_process(MAIL_TEMPLATE, self.user_employee.email_formatted, 'groups@test.com', subject='FirstFoundWinner')
+        self.assertEqual(record.create_uid, self.user_employee)
+        self.assertEqual(record.message_ids[0].subject, 'FirstFoundWinner')
+        self.assertEqual(record.message_ids[0].create_uid, self.user_employee)
+        self.assertEqual(record.message_ids[0].author_id, self.user_employee.partner_id)
+
+    # --------------------------------------------------
+    # Alias routing management
+    # --------------------------------------------------
+
+    @mute_logger('odoo.addons.mail.models.mail_thread', 'odoo.models')
+    def test_message_route_alias_no_domain(self):
+        """ Incoming email: write to alias even if no domain set: considered as valid alias """
+        self.env['ir.config_parameter'].set_param('mail.catchall.domain', '')
+
+        new_record = self.format_and_process(MAIL_TEMPLATE, self.partner_1.email_formatted, 'groups@another.domain.com', subject='Test Subject')
+        # Test: one group created
+        self.assertEqual(len(new_record), 1, 'message_process: a new mail.test.simple should have been created')
+
+    @mute_logger('odoo.addons.mail.models.mail_thread', 'odoo.models')
+    def test_message_route_alias_forward_bypass_reply_first(self):
+        """ Incoming email: write to two "new thread" alias, one as a reply, one being another model -> consider as a forward """
+        self.assertEqual(len(self.test_record.message_ids), 1)
+
+        # test@.. will cause the creation of new mail.test
+        new_alias_2 = self.env['mail.alias'].create({
+            'alias_name': 'test',
+            'alias_user_id': False,
+            'alias_model_id': self.env['ir.model']._get('mail.test.container').id,
+            'alias_contact': 'everyone',
+        })
+        new_rec = self.format_and_process(
+            MAIL_TEMPLATE, self.partner_1.email_formatted,
+            '%s@%s, %s@%s' % (new_alias_2.alias_name, self.alias_domain, self.alias.alias_name, self.alias_domain),
+            subject='Test Subject',
+            extra='In-Reply-To:\r\n\t%s\n' % self.fake_email.message_id,
+            target_model=new_alias_2.alias_model_id.model
+        )
+        # Forward created a new record in mail.test
+        self.assertEqual(len(new_rec), 1, 'message_process: a new mail.test should have been created')
+        self.assertEqual(new_rec._name, new_alias_2.alias_model_id.model)
+        # No new post on test_record, no new record in mail.test.simple either
+        self.assertEqual(len(self.test_record.message_ids), 1, 'message_process: should not post on replied record as forward should bypass it')
+        new_simple = self.env['mail.test.simple'].search([('name', '=', 'Test Subject')])
+        self.assertEqual(len(new_simple), 0, 'message_process: a new mail.test should not have been created')
+
+    @mute_logger('odoo.addons.mail.models.mail_thread', 'odoo.models')
+    def test_message_route_alias_forward_bypass_reply_second(self):
+        """ Incoming email: write to two "new thread" alias, one as a reply, one being another model -> consider as a forward """
+        self.assertEqual(len(self.test_record.message_ids), 1)
+
+        # test@.. will cause the creation of new mail.test
+        new_alias_2 = self.env['mail.alias'].create({
+            'alias_name': 'test',
+            'alias_user_id': False,
+            'alias_model_id': self.env['ir.model']._get('mail.test.container').id,
+            'alias_contact': 'everyone',
+        })
+        new_rec = self.format_and_process(
+            MAIL_TEMPLATE, self.partner_1.email_formatted,
+            '%s@%s, %s@%s' % (self.alias.alias_name, self.alias_domain, new_alias_2.alias_name, self.alias_domain),
+            subject='Test Subject',
+            extra='In-Reply-To:\r\n\t%s\n' % self.fake_email.message_id,
+            target_model=new_alias_2.alias_model_id.model
+        )
+        # Forward created a new record in mail.test
+        self.assertEqual(len(new_rec), 1, 'message_process: a new mail.test should have been created')
+        self.assertEqual(new_rec._name, new_alias_2.alias_model_id.model)
+        # No new post on test_record, no new record in mail.test.simple either
+        self.assertEqual(len(self.test_record.message_ids), 1, 'message_process: should not post on replied record as forward should bypass it')
+        new_simple = self.env['mail.test.simple'].search([('name', '=', 'Test Subject')])
+        self.assertEqual(len(new_simple), 0, 'message_process: a new mail.test should not have been created')
+
+    @mute_logger('odoo.addons.mail.models.mail_thread', 'odoo.models')
+    def test_message_route_alias_forward_bypass_update_alias(self):
+        """ Incoming email: write to one "update", one "new thread" alias, one as a reply, one being another model -> consider as a forward """
+        self.assertEqual(len(self.test_record.message_ids), 1)
+        self.alias.write({
+            'alias_force_thread_id': self.test_record.id,
+        })
+
+        # test@.. will cause the creation of new mail.test
+        new_alias_2 = self.env['mail.alias'].create({
+            'alias_name': 'test',
+            'alias_user_id': False,
+            'alias_model_id': self.env['ir.model']._get('mail.test.container').id,
+            'alias_contact': 'everyone',
+        })
+        new_rec = self.format_and_process(
+            MAIL_TEMPLATE, self.partner_1.email_formatted,
+            '%s@%s, %s@%s' % (new_alias_2.alias_name, self.alias_domain, self.alias.alias_name, self.alias_domain),
+            subject='Test Subject',
+            extra='In-Reply-To:\r\n\t%s\n' % self.fake_email.message_id,
+            target_model=new_alias_2.alias_model_id.model
+        )
+        # Forward created a new record in mail.test
+        self.assertEqual(len(new_rec), 1, 'message_process: a new mail.test should have been created')
+        self.assertEqual(new_rec._name, new_alias_2.alias_model_id.model)
+        # No new post on test_record, no new record in mail.test.simple either
+        self.assertEqual(len(self.test_record.message_ids), 1, 'message_process: should not post on replied record as forward should bypass it')
+        # No new record on first alias model
+        new_simple = self.env['mail.test.gateway'].search([('name', '=', 'Test Subject')])
+        self.assertEqual(len(new_simple), 0, 'message_process: a new mail.test should not have been created')
+
+    @mute_logger('odoo.addons.mail.models.mail_thread', 'odoo.models')
+    def test_message_route_alias_multiple_new(self):
+        """ Incoming email: write to two aliases creating records: both should be activated """
+        # test@.. will cause the creation of new mail.test
+        new_alias_2 = self.env['mail.alias'].create({
+            'alias_name': 'test',
+            'alias_user_id': False,
+            'alias_model_id': self.env['ir.model']._get('mail.test.container').id,
+            'alias_contact': 'everyone',
+        })
+        new_rec = self.format_and_process(
+            MAIL_TEMPLATE, self.partner_1.email_formatted,
+            '%s@%s, %s@%s' % (self.alias.alias_name, self.alias_domain, new_alias_2.alias_name, self.alias_domain),
+            subject='Test Subject',
+            target_model=new_alias_2.alias_model_id.model
+        )
+        # New record in both mail.test (new_alias_2) and mail.test.simple (self.alias)
+        self.assertEqual(len(new_rec), 1, 'message_process: a new mail.test should have been created')
+        self.assertEqual(new_rec._name, new_alias_2.alias_model_id.model)
+        new_simple = self.env['mail.test.gateway'].search([('name', '=', 'Test Subject')])
+        self.assertEqual(len(new_simple), 1, 'message_process: a new mail.test should have been created')
+
+    # --------------------------------------------------
+    # Email Management
+    # --------------------------------------------------
+
+    @mute_logger('odoo.addons.mail.models.mail_thread', 'odoo.models')
+    def test_message_route_bounce(self):
+        """Incoming email: bounce  using bounce alias: no record creation """
+        with self.mock_mail_gateway():
+            new_recs = self.format_and_process(
+                MAIL_TEMPLATE, self.partner_1.email_formatted,
+                '%s+%s-%s-%s@%s' % (
+                    self.alias_bounce, self.fake_email.id,
+                    self.fake_email.model, self.fake_email.res_id,
+                    self.alias_domain
+                ),
+                subject='Should bounce',
+            )
+        self.assertFalse(new_recs)
+        self.assertNotSentEmail()
+
+    @mute_logger('odoo.addons.mail.models.mail_thread', 'odoo.models')
+    def test_message_route_bounce_if_static_but_still_has_plus_addressing(self):
+        """Incoming email: bounce using bounce alias without plus addressing: keep old behavior."""
+        self.env['ir.config_parameter'].set_param('mail.bounce.alias.static', True)
+        with self.mock_mail_gateway():
+            new_recs = self.format_and_process(
+                MAIL_TEMPLATE, self.partner_1.email_formatted,
+                '%s+%s-%s-%s@%s' % (
+                    self.alias_bounce, self.fake_email.id,
+                    self.fake_email.model, self.fake_email.res_id,
+                    self.alias_domain
+                ),
+                subject='Should bounce',
+            )
+        self.assertFalse(new_recs)
+        self.assertEqual(len(self._mails), 0, 'message_process: incoming bounce produces no mails')
+
+    @mute_logger('odoo.addons.mail.models.mail_thread', 'odoo.models')
+    def test_message_route_bounce_if_static_without_plus_addressing(self):
+        """Incoming email: bounce using bounce alias without plus addressing: bounce it."""
+        self.env['ir.config_parameter'].set_param('mail.bounce.alias.static', True)
+        with self.mock_mail_gateway():
+            new_recs = self.format_and_process(
+                MAIL_TEMPLATE, self.partner_1.email_formatted,
+                '%s@%s' % (self.alias_bounce, self.alias_domain),
+                subject='Should bounce',
+            )
+        self.assertFalse(new_recs)
+        self.assertEqual(len(self._mails), 0, 'message_process: incoming bounce produces no mails')
+
+    @mute_logger('odoo.addons.mail.models.mail_thread', 'odoo.models')
+    def test_message_route_no_bounce_if_not_static_without_plus_addressing(self):
+        """Incoming email: bounce using bounce alias without plus addressing: raise as
+        considering as a direct write to bounce alias -> invalid """
+        self.env['ir.config_parameter'].set_param('mail.bounce.alias.static', False)
+        with self.assertRaises(ValueError):
+            self.format_and_process(
+                MAIL_TEMPLATE, self.partner_1.email_formatted,
+                '%s@%s' % (self.alias_bounce, self.alias_domain),
+                subject="Should fail because it is not a bounce and there's no alias",
+            )
+
+    @mute_logger('odoo.addons.mail.models.mail_thread', 'odoo.models')
+    def test_message_route_bounce_other_recipients(self):
+        """Incoming email: bounce processing: bounce should be computed even if not first recipient """
+        with self.mock_mail_gateway():
+            new_recs = self.format_and_process(
+                MAIL_TEMPLATE, self.partner_1.email_formatted,
+                '%s@%s, %s+%s-%s-%s@%s' % (
+                    self.alias.alias_name, self.alias_domain,
+                    self.alias_bounce, self.fake_email.id,
+                    self.fake_email.model, self.fake_email.res_id,
+                    self.alias_domain
+                ),
+                subject='Should bounce',
+            )
+        self.assertFalse(new_recs)
+        self.assertNotSentEmail()
+
+    @mute_logger('odoo.addons.mail.models.mail_thread', 'odoo.addons.mail.models.mail_mail', 'odoo.models.unlink')
+    def test_message_route_write_to_catchall(self):
+        """ Writing directly to catchall should bounce """
+        # Test: no group created, email bounced
+        with self.mock_mail_gateway():
+            record = self.format_and_process(
+                MAIL_TEMPLATE, self.partner_1.email_formatted,
+                '"My Super Catchall" <%s@%s>' % (self.alias_catchall, self.alias_domain),
+                subject='Should Bounce')
+        self.assertFalse(record)
+        self.assertSentEmail('"MAILER-DAEMON" <bounce.test@test.com>', ['whatever-2a840@postmaster.twitter.com'], subject='Re: Should Bounce')
+
+    @mute_logger('odoo.addons.mail.models.mail_thread', 'odoo.models')
+    def test_message_route_write_to_catchall_other_recipients_first(self):
+        """ Writing directly to catchall and a valid alias should take alias """
+        # Test: no group created, email bounced
+        with self.mock_mail_gateway():
+            record = self.format_and_process(
+                MAIL_TEMPLATE, self.partner_1.email_formatted,
+                '%s@%s, %s@%s' % (self.alias_catchall, self.alias_domain, self.alias.alias_name, self.alias_domain),
+                subject='Catchall Not Blocking'
+            )
+        # Test: one group created
+        self.assertEqual(len(record), 1, 'message_process: a new mail.test should have been created')
+        # No bounce email
+        self.assertNotSentEmail()
+
+    @mute_logger('odoo.addons.mail.models.mail_thread', 'odoo.models')
+    def test_message_route_write_to_catchall_other_recipients_second(self):
+        """ Writing directly to catchall and a valid alias should take alias """
+        # Test: no group created, email bounced
+        with self.mock_mail_gateway():
+            record = self.format_and_process(
+                MAIL_TEMPLATE, self.partner_1.email_formatted,
+                '%s@%s, %s@%s' % (self.alias.alias_name, self.alias_domain, self.alias_catchall, self.alias_domain),
+                subject='Catchall Not Blocking'
+            )
+        # Test: one group created
+        self.assertEqual(len(record), 1, 'message_process: a new mail.test should have been created')
+        # No bounce email
+        self.assertNotSentEmail()
+
+    @mute_logger('odoo.addons.mail.models.mail_thread')
+    def test_message_process_bounce_alias(self):
+        """ Writing to bounce alias is considered as a bounce even if not multipart/report bounce structure """
+        self.assertEqual(self.partner_1.message_bounce, 0)
+        self.assertEqual(self.test_record.message_bounce, 0)
+
+        bounced_mail_id = 4442
+        bounce_email_to = '%s+%s-%s-%s@%s' % ('bounce.test', bounced_mail_id, self.test_record._name, self.test_record.id, 'test.com')
+        record = self.format_and_process(MAIL_TEMPLATE, self.partner_1.email_formatted, bounce_email_to, subject='Undelivered Mail Returned to Sender')
+        self.assertFalse(record)
+        # No information found in bounce email -> not possible to do anything except avoiding email
+        self.assertEqual(self.partner_1.message_bounce, 0)
+        self.assertEqual(self.test_record.message_bounce, 0)
+
+    @mute_logger('odoo.addons.mail.models.mail_thread')
+    def test_message_process_bounce_from_mailer_demon(self):
+        """ MAILER_DAEMON emails are considered as bounce """
+        self.assertEqual(self.partner_1.message_bounce, 0)
+        self.assertEqual(self.test_record.message_bounce, 0)
+
+        record = self.format_and_process(MAIL_TEMPLATE, 'MAILER-DAEMON@example.com', 'groups@test.com', subject='Undelivered Mail Returned to Sender')
+        self.assertFalse(record)
+        # No information found in bounce email -> not possible to do anything except avoiding email
+        self.assertEqual(self.partner_1.message_bounce, 0)
+        self.assertEqual(self.test_record.message_bounce, 0)
+
+    @mute_logger('odoo.addons.mail.models.mail_thread')
+    def test_message_process_bounce_multipart_alias(self):
+        """ Multipart/report bounce correctly make related partner bounce """
+        self.assertEqual(self.partner_1.message_bounce, 0)
+        self.assertEqual(self.test_record.message_bounce, 0)
+
+        bounced_mail_id = 4442
+        bounce_email_to = '%s+%s-%s-%s@%s' % ('bounce.test', bounced_mail_id, self.test_record._name, self.test_record.id, 'test.com')
+        record = self.format_and_process(test_mail_data.MAIL_BOUNCE, self.partner_1.email_formatted, bounce_email_to, subject='Undelivered Mail Returned to Sender')
+        self.assertFalse(record)
+        # Missing in reply to message_id -> cannot find original record
+        self.assertEqual(self.partner_1.message_bounce, 1)
+        self.assertEqual(self.test_record.message_bounce, 0)
+
+    @mute_logger('odoo.addons.mail.models.mail_thread')
+    def test_message_process_bounce_multipart_alias_reply(self):
+        """ Multipart/report bounce correctly make related partner and record found in bounce email bounce """
+        self.assertEqual(self.partner_1.message_bounce, 0)
+        self.assertEqual(self.test_record.message_bounce, 0)
+
+        bounced_mail_id = 4442
+        bounce_email_to = '%s+%s-%s-%s@%s' % ('bounce.test', bounced_mail_id, self.test_record._name, self.test_record.id, 'test.com')
+        extra = self.fake_email.message_id
+        record = self.format_and_process(test_mail_data.MAIL_BOUNCE, self.partner_1.email_formatted, bounce_email_to, subject='Undelivered Mail Returned to Sender', extra=extra)
+        self.assertFalse(record)
+        self.assertEqual(self.partner_1.message_bounce, 1)
+        self.assertEqual(self.test_record.message_bounce, 1)
+
+    @mute_logger('odoo.addons.mail.models.mail_thread')
+    def test_message_process_bounce_multipart_alias_whatever_from(self):
+        """ Multipart/report bounce correctly make related record found in bounce email bounce """
+        self.assertEqual(self.partner_1.message_bounce, 0)
+        self.assertEqual(self.test_record.message_bounce, 0)
+
+        bounced_mail_id = 4442
+        bounce_email_to = '%s+%s-%s-%s@%s' % ('bounce.test', bounced_mail_id, self.test_record._name, self.test_record.id, 'test.com')
+        extra = self.fake_email.message_id
+        record = self.format_and_process(test_mail_data.MAIL_BOUNCE, 'Whatever <what@ever.com>', bounce_email_to, subject='Undelivered Mail Returned to Sender', extra=extra)
+        self.assertFalse(record)
+        self.assertEqual(self.partner_1.message_bounce, 0)
+        self.assertEqual(self.test_record.message_bounce, 1)
+
+    @mute_logger('odoo.addons.mail.models.mail_thread')
+    def test_message_process_bounce_multipart_whatever_to_and_from(self):
+        """ Multipart/report bounce correctly make related record found in bounce email bounce """
+        self.assertEqual(self.partner_1.message_bounce, 0)
+        self.assertEqual(self.test_record.message_bounce, 0)
+
+        extra = self.fake_email.message_id
+        record = self.format_and_process(test_mail_data.MAIL_BOUNCE, 'Whatever <what@ever.com>', 'groups@test.com', subject='Undelivered Mail Returned to Sender', extra=extra)
+        self.assertFalse(record)
+        self.assertEqual(self.partner_1.message_bounce, 0)
+        self.assertEqual(self.test_record.message_bounce, 1)
+
+    @mute_logger('odoo.addons.mail.models.mail_thread')
+    def test_message_process_bounce_records_channel(self):
+        """ Test blacklist allow to multi-bounce and auto update of mail.channel """
+        other_record = self.env['mail.test.gateway'].create({
+            'email_from': 'Another name <%s>' % self.partner_1.email
+        })
+        yet_other_record = self.env['mail.test.gateway'].create({
+            'email_from': 'Yet Another name <%s>' % self.partner_1.email.upper()
+        })
+        test_channel = self.env['mail.channel'].create({
+            'name': 'Test',
+            'channel_last_seen_partner_ids': [(0, 0, {'partner_id': self.partner_1.id})],
+        })
+        self.fake_email.write({
+            'model': 'mail.channel',
+            'res_id': test_channel.id,
+        })
+        self.assertIn(self.partner_1, test_channel.channel_partner_ids)
+        self.assertEqual(self.partner_1.message_bounce, 0)
+        self.assertEqual(other_record.message_bounce, 0)
+        self.assertEqual(yet_other_record.message_bounce, 0)
+
+        extra = self.fake_email.message_id
+        for i in range(10):
+            record = self.format_and_process(test_mail_data.MAIL_BOUNCE, 'A third name <%s>' % self.partner_1.email, 'groups@test.com', subject='Undelivered Mail Returned to Sender', extra=extra)
+            self.assertFalse(record)
+        self.assertEqual(self.partner_1.message_bounce, 10)
+        self.assertEqual(self.test_record.message_bounce, 0)
+        self.assertEqual(other_record.message_bounce, 10)
+        self.assertEqual(yet_other_record.message_bounce, 10)
+        self.assertNotIn(self.partner_1, test_channel.channel_partner_ids)
+
+    @mute_logger('odoo.addons.mail.models.mail_thread')
+    def test_message_process_bounce_records_partner(self):
+        """ Test blacklist + bounce on ``res.partner`` model """
+        self.assertEqual(self.partner_1.message_bounce, 0)
+        self.fake_email.write({
+            'model': 'res.partner',
+            'res_id': self.partner_1.id,
+        })
+
+        extra = self.fake_email.message_id
+        record = self.format_and_process(test_mail_data.MAIL_BOUNCE, self.partner_1.email_formatted, 'groups@test.com', subject='Undelivered Mail Returned to Sender', extra=extra)
+        self.assertFalse(record)
+        self.assertEqual(self.partner_1.message_bounce, 1)
+        self.assertEqual(self.test_record.message_bounce, 0)
+
+    # --------------------------------------------------
+    # Thread formation
+    # --------------------------------------------------
+
+    @mute_logger('odoo.addons.mail.models.mail_thread', 'odoo.models')
+    def test_message_process_in_reply_to(self):
+        """ Incoming email using in-rely-to should go into the right destination even with a wrong destination """
+        init_msg_count = len(self.test_record.message_ids)
+        self.format_and_process(
+            MAIL_TEMPLATE, 'valid.other@gmail.com', 'erroneous@test.com>',
+            subject='Re: news', extra='In-Reply-To:\r\n\t%s\n' % self.fake_email.message_id)
+
+        self.assertEqual(len(self.test_record.message_ids), init_msg_count + 1)
+        self.assertEqual(self.fake_email.child_ids, self.test_record.message_ids[0])
+
+    @mute_logger('odoo.addons.mail.models.mail_thread', 'odoo.models')
+    def test_message_process_references(self):
+        """ Incoming email using references should go into the right destination even with a wrong destination """
+        init_msg_count = len(self.test_record.message_ids)
+        self.format_and_process(
+            MAIL_TEMPLATE, self.email_from, 'erroneous@test.com',
+            extra='References: <2233@a.com>\r\n\t<3edss_dsa@b.com> %s' % self.fake_email.message_id)
+
+        self.assertEqual(len(self.test_record.message_ids), init_msg_count + 1)
+        self.assertEqual(self.fake_email.child_ids, self.test_record.message_ids[0])
+
+    @mute_logger('odoo.addons.mail.models.mail_thread')
+    def test_message_process_references_external(self):
+        """ Incoming email being a reply to an external email processed by odoo should update thread accordingly """
+        new_message_id = '<ThisIsTooMuchFake.MonsterEmail.789@agrolait.com>'
+        self.fake_email.write({
+            'message_id': new_message_id
+        })
+        init_msg_count = len(self.test_record.message_ids)
+        self.format_and_process(
+            MAIL_TEMPLATE, self.email_from, 'erroneous@test.com',
+            extra='References: <2233@a.com>\r\n\t<3edss_dsa@b.com> %s' % self.fake_email.message_id)
+
+        self.assertEqual(len(self.test_record.message_ids), init_msg_count + 1)
+        self.assertEqual(self.fake_email.child_ids, self.test_record.message_ids[0])
+
+    @mute_logger('odoo.addons.mail.models.mail_thread')
+    def test_message_process_references_external_buggy_message_id(self):
+        """
+        Incoming email being a reply to an external email processed by
+        odoo should update thread accordingly. Special case when the
+        external mail service wrongly folds the message_id on several
+        lines.
+        """
+        new_message_id = '<ThisIsTooMuchFake.MonsterEmail.789@agrolait.com>'
+        buggy_message_id = new_message_id.replace('MonsterEmail', 'Monster\r\n  Email')
+        self.fake_email.write({
+            'message_id': new_message_id
+        })
+        init_msg_count = len(self.test_record.message_ids)
+        self.format_and_process(
+            MAIL_TEMPLATE, self.email_from, 'erroneous@test.com',
+            extra='References: <2233@a.com>\r\n\t<3edss_dsa@b.com> %s' % buggy_message_id)
+
+        self.assertEqual(len(self.test_record.message_ids), init_msg_count + 1)
+        self.assertEqual(self.fake_email.child_ids, self.test_record.message_ids[0])
+
+    @mute_logger('odoo.addons.mail.models.mail_thread')
+    def test_message_process_references_forward(self):
+        """ Incoming email using references but with alias forward should not go into references destination """
+        self.env['mail.alias'].create({
+            'alias_name': 'test.alias',
+            'alias_user_id': False,
+            'alias_model_id': self.env['ir.model']._get('mail.test.container').id,
+            'alias_contact': 'everyone',
+        })
+        init_msg_count = len(self.test_record.message_ids)
+        res_test = self.format_and_process(
+            MAIL_TEMPLATE, self.email_from, 'test.alias@test.com',
+            subject='My Dear Forward', extra='References: <2233@a.com>\r\n\t<3edss_dsa@b.com> %s' % self.fake_email.message_id,
+            target_model='mail.test.container')
+
+        self.assertEqual(len(self.test_record.message_ids), init_msg_count)
+        self.assertEqual(len(self.fake_email.child_ids), 0)
+        self.assertEqual(res_test.name, 'My Dear Forward')
+        self.assertEqual(len(res_test.message_ids), 1)
+
+    @mute_logger('odoo.addons.mail.models.mail_thread', 'odoo.models')
+    def test_message_process_references_forward_same_model(self):
+        """ Incoming email using references but with alias forward on same model should be considered as a reply """
+        self.env['mail.alias'].create({
+            'alias_name': 'test.alias',
+            'alias_user_id': False,
+            'alias_model_id': self.env['ir.model']._get('mail.test.gateway').id,
+            'alias_contact': 'everyone',
+        })
+        init_msg_count = len(self.test_record.message_ids)
+        res_test = self.format_and_process(
+            MAIL_TEMPLATE, self.email_from, 'test.alias@test.com',
+            subject='My Dear Forward', extra='References: <2233@a.com>\r\n\t<3edss_dsa@b.com> %s' % self.fake_email.message_id,
+            target_model='mail.test.container')
+
+        self.assertEqual(len(self.test_record.message_ids), init_msg_count + 1)
+        self.assertEqual(len(self.fake_email.child_ids), 1)
+        self.assertFalse(res_test)
+
+    @mute_logger('odoo.addons.mail.models.mail_thread', 'odoo.models')
+    def test_message_process_references_forward_cc(self):
+        """ Incoming email using references but with alias forward in CC should be considered as a repy (To > Cc) """
+        self.env['mail.alias'].create({
+            'alias_name': 'test.alias',
+            'alias_user_id': False,
+            'alias_model_id': self.env['ir.model']._get('mail.test.container').id,
+            'alias_contact': 'everyone',
+        })
+        init_msg_count = len(self.test_record.message_ids)
+        res_test = self.format_and_process(
+            MAIL_TEMPLATE, self.email_from, 'catchall.test@test.com', cc='test.alias@test.com',
+            subject='My Dear Forward', extra='References: <2233@a.com>\r\n\t<3edss_dsa@b.com> %s' % self.fake_email.message_id,
+            target_model='mail.test.container')
+
+        self.assertEqual(len(self.test_record.message_ids), init_msg_count + 1)
+        self.assertEqual(len(self.fake_email.child_ids), 1)
+        self.assertFalse(res_test)
+
+    @mute_logger('odoo.addons.mail.models.mail_thread', 'odoo.models', 'odoo.addons.mail.models.mail_mail')
+    def test_message_process_reply_to_new_thread(self):
+        """ Test replies not being considered as replies but use destination information instead (aka, mass post + specific reply to using aliases) """
+        first_record = self.env['mail.test.simple'].with_user(self.user_employee).create({'name': 'Replies to Record'})
+        record_msg = first_record.message_post(
+            subject='Discussion',
+            no_auto_thread=False,
+            subtype_xmlid='mail.mt_comment',
+        )
+        self.assertEqual(record_msg.reply_to, formataddr(('%s %s' % (self.user_employee.company_id.name, first_record.name), '%s@%s' % ('catchall.test', 'test.com'))))
+        mail_msg = first_record.message_post(
+            subject='Replies to Record',
+            reply_to='groups@test.com',
+            no_auto_thread=True,
+            subtype_xmlid='mail.mt_comment',
+        )
+        self.assertEqual(mail_msg.reply_to, 'groups@test.com')
+
+        # reply to mail but should be considered as a new mail for alias
+        msgID = '<this.is.duplicate.test@iron.sky>'
+        res_test = self.format_and_process(
+            MAIL_TEMPLATE, self.email_from, record_msg.reply_to, cc='',
+            subject='Re: Replies to Record', extra='In-Reply-To: %s' % record_msg.message_id,
+            msg_id=msgID, target_model='mail.test.simple')
+        incoming_msg = self.env['mail.message'].search([('message_id', '=', msgID)])
+        self.assertFalse(res_test)
+        self.assertEqual(incoming_msg.model, 'mail.test.simple')
+        self.assertEqual(incoming_msg.parent_id, first_record.message_ids[-1])
+        self.assertTrue(incoming_msg.res_id == first_record.id)
+
+        # reply to mail but should be considered as a new mail for alias
+        msgID = '<this.is.for.testing@iron.sky>'
+        res_test = self.format_and_process(
+            MAIL_TEMPLATE, self.email_from, mail_msg.reply_to, cc='',
+            subject='Re: Replies to Record', extra='In-Reply-To: %s' % mail_msg.message_id,
+            msg_id=msgID, target_model='mail.test.gateway')
+        incoming_msg = self.env['mail.message'].search([('message_id', '=', msgID)])
+        self.assertEqual(len(res_test), 1)
+        self.assertEqual(res_test.name, 'Re: Replies to Record')
+        self.assertEqual(incoming_msg.model, 'mail.test.gateway')
+        self.assertFalse(incoming_msg.parent_id)
+        self.assertTrue(incoming_msg.res_id == res_test.id)
+
+    # --------------------------------------------------
+    # Thread formation: mail gateway corner cases
+    # --------------------------------------------------
+
+    @mute_logger('odoo.addons.mail.models.mail_thread', 'odoo.models')
+    def test_message_process_extra_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,
+                          self.partner_1.email_formatted, 'noone@test.com', subject='spam',
+                          extra='In-Reply-To: <12321321-openerp-%d-mail.test.gateway@%s>' % (self.test_record.id, socket.gethostname()))
+
+        # when 6.1 messages are present, compat mode is available
+        # Odoo 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,
+            self.partner_1.email_formatted, 'noone@test.com>', subject='spam',
+            extra='In-Reply-To: <12321321-openerp-%d-mail.test.gateway@%s>' % (self.test_record.id, socket.gethostname()))
+
+        # Test created messages
+        self.assertEqual(len(self.test_record.message_ids), 1)
+        self.assertEqual(len(self.test_record.message_ids[0].child_ids), 0)
+
+    @mute_logger('odoo.addons.mail.models.mail_thread', 'odoo.models')
+    def test_message_process_duplicate(self):
+        """ Duplicate emails (same message_id) are not processed """
+        self.alias.write({'alias_force_thread_id': self.test_record.id,})
+
+        # Post a base message
+        record = self.format_and_process(MAIL_TEMPLATE, self.email_from, 'groups@test.com', subject='Re: super cats', msg_id='<123?456.diff1@agrolait.com>')
+        self.assertFalse(record)
+        self.assertEqual(len(self.test_record.message_ids), 2)
+
+        # Do: due to some issue, same email goes back into the mailgateway
+        record = self.format_and_process(
+            MAIL_TEMPLATE, self.email_from, 'groups@test.com', subject='Re: news',
+            msg_id='<123?456.diff1@agrolait.com>', extra='In-Reply-To: <1198923581.41972151344608186799.JavaMail.diff1@agrolait.com>\n')
+        self.assertFalse(record)
+        self.assertEqual(len(self.test_record.message_ids), 2)
+
+        # Test: message_id is still unique
+        no_of_msg = self.env['mail.message'].search_count([('message_id', 'ilike', '<123?456.diff1@agrolait.com>')])
+        self.assertEqual(no_of_msg, 1,
+                         'message_process: message with already existing message_id should not have been duplicated')
+
+    @mute_logger('odoo.addons.mail.models.mail_thread', 'odoo.models')
+    def test_message_process_crash_wrong_model(self):
+        """ Incoming email with model that does not accepts incoming emails must raise """
+        self.assertRaises(ValueError,
+                          self.format_and_process,
+                          MAIL_TEMPLATE, self.email_from, 'noone@test.com',
+                          subject='spam', extra='', model='res.country')
+
+    @mute_logger('odoo.addons.mail.models.mail_thread', 'odoo.models')
+    def test_message_process_crash_no_data(self):
+        """ Incoming email without model and without alias must raise """
+        self.assertRaises(ValueError,
+                          self.format_and_process,
+                          MAIL_TEMPLATE, self.email_from, 'noone@test.com',
+                          subject='spam', extra='')
+
+    @mute_logger('odoo.addons.mail.models.mail_thread', 'odoo.models')
+    def test_message_process_fallback(self):
+        """ Incoming email with model that accepting incoming emails as fallback """
+        record = self.format_and_process(
+            MAIL_TEMPLATE, self.email_from, 'noone@test.com',
+            subject='Spammy', extra='', model='mail.test.gateway')
+        self.assertEqual(len(record), 1)
+        self.assertEqual(record.name, 'Spammy')
+        self.assertEqual(record._name, 'mail.test.gateway')
+
+
+class TestMailThreadCC(TestMailCommon):
+
+    @classmethod
+    def setUpClass(cls):
+        super(TestMailThreadCC, cls).setUpClass()
+
+        cls.email_from = 'Sylvie Lelitre <test.sylvie.lelitre@agrolait.com>'
+        cls.alias = cls.env['mail.alias'].create({
+            'alias_name': 'cc_record',
+            'alias_user_id': False,
+            'alias_model_id': cls.env['ir.model']._get('mail.test.cc').id,
+            'alias_contact': 'everyone'})
+
+        cls._init_mail_gateway()
+
+    @mute_logger('odoo.addons.mail.models.mail_thread')
+    def test_message_cc_new(self):
+        record = self.format_and_process(MAIL_TEMPLATE, self.email_from, 'cc_record@test.com',
+                                         cc='cc1@example.com, cc2@example.com', target_model='mail.test.cc')
+        cc = email_split_and_format(record.email_cc)
+        self.assertEqual(sorted(cc), ['cc1@example.com', 'cc2@example.com'])
+
+    @mute_logger('odoo.addons.mail.models.mail_thread')
+    def test_message_cc_update_with_old(self):
+        record = self.env['mail.test.cc'].create({'email_cc': 'cc1 <cc1@example.com>, cc2@example.com'})
+        self.alias.write({'alias_force_thread_id': record.id})
+
+        self.format_and_process(MAIL_TEMPLATE, self.email_from, 'cc_record@test.com',
+                                cc='cc2 <cc2@example.com>, cc3@example.com', target_model='mail.test.cc')
+        cc = email_split_and_format(record.email_cc)
+        self.assertEqual(sorted(cc), ['"cc1" <cc1@example.com>', 'cc2@example.com', 'cc3@example.com'], 'new cc should have been added on record (unique)')
+
+    @mute_logger('odoo.addons.mail.models.mail_thread')
+    def test_message_cc_update_no_old(self):
+        record = self.env['mail.test.cc'].create({})
+        self.alias.write({'alias_force_thread_id': record.id})
+
+        self.format_and_process(MAIL_TEMPLATE, self.email_from, 'cc_record@test.com',
+                                cc='cc2 <cc2@example.com>, cc3@example.com', target_model='mail.test.cc')
+        cc = email_split_and_format(record.email_cc)
+        self.assertEqual(sorted(cc), ['"cc2" <cc2@example.com>', 'cc3@example.com'], 'new cc should have been added on record (unique)')
diff --git a/addons/test_mail/tests/test_mail_mail.py b/addons/test_mail/tests/test_mail_mail.py
new file mode 100644
index 00000000..3ebee263
--- /dev/null
+++ b/addons/test_mail/tests/test_mail_mail.py
@@ -0,0 +1,141 @@
+# -*- coding: utf-8 -*-
+# Part of Odoo. See LICENSE file for full copyright and licensing details.
+
+import psycopg2
+
+from odoo import api
+from odoo.addons.test_mail.tests.common import TestMailCommon
+from odoo.tests import common, tagged
+from odoo.tools import mute_logger
+
+
+@tagged('mail_mail')
+class TestMailMail(TestMailCommon):
+
+    @classmethod
+    def setUpClass(cls):
+        super(TestMailMail, cls).setUpClass()
+        cls._init_mail_gateway()
+
+        cls.test_record = cls.env['mail.test.gateway'].with_context(cls._test_context).create({
+            'name': 'Test',
+            'email_from': 'ignasse@example.com',
+        }).with_context({})
+
+    @mute_logger('odoo.addons.mail.models.mail_mail')
+    def test_mail_message_notify_from_mail_mail(self):
+        # Due ot post-commit hooks, store send emails in every step
+        mail = self.env['mail.mail'].sudo().create({
+            'body_html': '<p>Test</p>',
+            'email_to': 'test@example.com',
+            'partner_ids': [(4, self.user_employee.partner_id.id)]
+        })
+        with self.mock_mail_gateway():
+            mail.send()
+        self.assertSentEmail(mail.env.user.partner_id, ['test@example.com'])
+        self.assertEqual(len(self._mails), 1)
+
+    def test_mail_mail_return_path(self):
+        # mail without thread-enabled record
+        base_values = {
+            'body_html': '<p>Test</p>',
+            'email_to': 'test@example.com',
+        }
+
+        mail = self.env['mail.mail'].create(base_values)
+        with self.mock_mail_gateway():
+            mail.send()
+        self.assertEqual(self._mails[0]['headers']['Return-Path'], '%s+%d@%s' % (self.alias_bounce, mail.id, self.alias_domain))
+
+        # mail on thread-enabled record
+        mail = self.env['mail.mail'].create(dict(base_values, **{
+            'model': self.test_record._name,
+            'res_id': self.test_record.id,
+        }))
+        with self.mock_mail_gateway():
+            mail.send()
+        self.assertEqual(self._mails[0]['headers']['Return-Path'], '%s+%d-%s-%s@%s' % (self.alias_bounce, mail.id, self.test_record._name, self.test_record.id, self.alias_domain))
+
+        # force static addressing on bounce alias
+        self.env['ir.config_parameter'].set_param('mail.bounce.alias.static', True)
+
+        # mail without thread-enabled record
+        mail = self.env['mail.mail'].create(base_values)
+        with self.mock_mail_gateway():
+            mail.send()
+        self.assertEqual(self._mails[0]['headers']['Return-Path'], '%s@%s' % (self.alias_bounce, self.alias_domain))
+
+        # mail on thread-enabled record
+        mail = self.env['mail.mail'].create(dict(base_values, **{
+            'model': self.test_record._name,
+            'res_id': self.test_record.id,
+        }))
+        with self.mock_mail_gateway():
+            mail.send()
+        self.assertEqual(self._mails[0]['headers']['Return-Path'], '%s@%s' % (self.alias_bounce, self.alias_domain))
+
+
+class TestMailMailRace(common.TransactionCase):
+
+    @mute_logger('odoo.addons.mail.models.mail_mail')
+    def test_mail_bounce_during_send(self):
+        self.partner = self.env['res.partner'].create({
+            'name': 'Ernest Partner',
+        })
+        # we need to simulate a mail sent by the cron task, first create mail, message and notification by hand
+        mail = self.env['mail.mail'].sudo().create({
+            'body_html': '<p>Test</p>',
+            'notification': True,
+            'state': 'outgoing',
+            'recipient_ids': [(4, self.partner.id)]
+        })
+        message = self.env['mail.message'].create({
+            'subject': 'S',
+            'body': 'B',
+            'subtype_id': self.ref('mail.mt_comment'),
+            'notification_ids': [(0, 0, {
+                'res_partner_id': self.partner.id,
+                'mail_id': mail.id,
+                'notification_type': 'email',
+                'is_read': True,
+                'notification_status': 'ready',
+            })],
+        })
+        notif = self.env['mail.notification'].search([('res_partner_id', '=', self.partner.id)])
+        # we need to commit transaction or cr will keep the lock on notif
+        self.cr.commit()
+
+        # patch send_email in order to create a concurent update and check the notif is already locked by _send()
+        this = self  # coding in javascript ruinned my life
+        bounce_deferred = []
+        @api.model
+        def send_email(self, message, *args, **kwargs):
+            with this.registry.cursor() as cr, mute_logger('odoo.sql_db'):
+                try:
+                    # try ro aquire lock (no wait) on notification (should fail)
+                    cr.execute("SELECT notification_status FROM mail_message_res_partner_needaction_rel WHERE id = %s FOR UPDATE NOWAIT", [notif.id])
+                except psycopg2.OperationalError:
+                    # record already locked by send, all good
+                    bounce_deferred.append(True)
+                else:
+                    # this should trigger psycopg2.extensions.TransactionRollbackError in send().
+                    # Only here to simulate the initial use case
+                    # If the record is lock, this line would create a deadlock since we are in the same thread
+                    # In practice, the update will wait the end of the send() transaction and set the notif as bounce, as expeced
+                    cr.execute("UPDATE mail_message_res_partner_needaction_rel SET notification_status='bounce' WHERE id = %s", [notif.id])
+            return message['Message-Id']
+        self.env['ir.mail_server']._patch_method('send_email', send_email)
+
+        mail.send()
+
+        self.assertTrue(bounce_deferred, "The bounce should have been deferred")
+        self.assertEqual(notif.notification_status, 'sent')
+
+        # some cleaning since we commited the cr
+        self.env['ir.mail_server']._revert_method('send_email')
+
+        notif.unlink()
+        message.unlink()
+        mail.unlink()
+        self.partner.unlink()
+        self.env.cr.commit()
diff --git a/addons/test_mail/tests/test_mail_message.py b/addons/test_mail/tests/test_mail_message.py
new file mode 100644
index 00000000..8d384f72
--- /dev/null
+++ b/addons/test_mail/tests/test_mail_message.py
@@ -0,0 +1,591 @@
+# -*- coding: utf-8 -*-
+# Part of Odoo. See LICENSE file for full copyright and licensing details.
+
+import base64
+from unittest.mock import patch
+
+from odoo.addons.mail.tests.common import mail_new_test_user
+from odoo.addons.test_mail.tests.common import TestMailCommon
+from odoo.addons.test_mail.models.test_mail_models import MailTestSimple
+from odoo.exceptions import AccessError
+from odoo.tools import mute_logger, formataddr
+from odoo.tests import tagged
+
+
+class TestMessageValues(TestMailCommon):
+
+    @classmethod
+    def setUpClass(cls):
+        super(TestMessageValues, cls).setUpClass()
+
+        cls._init_mail_gateway()
+        cls.alias_record = cls.env['mail.test.container'].with_context(cls._test_context).create({
+            'name': 'Pigs',
+            'alias_name': 'pigs',
+            'alias_contact': 'followers',
+        })
+        cls.Message = cls.env['mail.message'].with_user(cls.user_employee)
+
+    @mute_logger('odoo.models.unlink')
+    def test_mail_message_format(self):
+        record1 = self.env['mail.test.simple'].create({'name': 'Test1'})
+        message = self.env['mail.message'].create([{
+            'model': 'mail.test.simple',
+            'res_id': record1.id,
+        }])
+        res = message.message_format()
+        self.assertEqual(res[0].get('record_name'), 'Test1')
+
+        record1.write({"name": "Test2"})
+        res = message.message_format()
+        self.assertEqual(res[0].get('record_name'), 'Test2')
+
+    @mute_logger('odoo.models.unlink')
+    def test_mail_message_format_access(self):
+        """
+        User that doesn't have access to a record should still be able to fetch
+        the record_name inside message_format.
+        """
+        company_2 = self.env['res.company'].create({'name': 'Second Test Company'})
+        record1 = self.env['mail.test.multi.company'].create({
+            'name': 'Test1',
+            'company_id': company_2.id,
+        })
+        message = record1.message_post(body='', partner_ids=[self.user_employee.partner_id.id])
+        # We need to flush and invalidate the ORM cache since the record_name
+        # is already cached from the creation. Otherwise it will leak inside
+        # message_format.
+        message.flush()
+        message.invalidate_cache()
+        res = message.with_user(self.user_employee).message_format()
+        self.assertEqual(res[0].get('record_name'), 'Test1')
+
+    @mute_logger('odoo.models.unlink')
+    def test_mail_message_values_no_document_values(self):
+        msg = self.Message.create({
+            'reply_to': 'test.reply@example.com',
+            'email_from': 'test.from@example.com',
+        })
+        self.assertIn('-private', msg.message_id.split('@')[0], 'mail_message: message_id for a void message should be a "private" one')
+        self.assertEqual(msg.reply_to, 'test.reply@example.com')
+        self.assertEqual(msg.email_from, 'test.from@example.com')
+
+    @mute_logger('odoo.models.unlink')
+    def test_mail_message_values_no_document(self):
+        msg = self.Message.create({})
+        self.assertIn('-private', msg.message_id.split('@')[0], 'mail_message: message_id for a void message should be a "private" one')
+        reply_to_name = self.env.user.company_id.name
+        reply_to_email = '%s@%s' % (self.alias_catchall, self.alias_domain)
+        self.assertEqual(msg.reply_to, formataddr((reply_to_name, reply_to_email)))
+        self.assertEqual(msg.email_from, formataddr((self.user_employee.name, self.user_employee.email)))
+
+        # no alias domain -> author
+        self.env['ir.config_parameter'].search([('key', '=', 'mail.catchall.domain')]).unlink()
+
+        msg = self.Message.create({})
+        self.assertIn('-private', msg.message_id.split('@')[0], 'mail_message: message_id for a void message should be a "private" one')
+        self.assertEqual(msg.reply_to, formataddr((self.user_employee.name, self.user_employee.email)))
+        self.assertEqual(msg.email_from, formataddr((self.user_employee.name, self.user_employee.email)))
+
+        # no alias catchall, no alias -> author
+        self.env['ir.config_parameter'].set_param('mail.catchall.domain', self.alias_domain)
+        self.env['ir.config_parameter'].search([('key', '=', 'mail.catchall.alias')]).unlink()
+
+        msg = self.Message.create({})
+        self.assertIn('-private', msg.message_id.split('@')[0], 'mail_message: message_id for a void message should be a "private" one')
+        self.assertEqual(msg.reply_to, formataddr((self.user_employee.name, self.user_employee.email)))
+        self.assertEqual(msg.email_from, formataddr((self.user_employee.name, self.user_employee.email)))
+
+    @mute_logger('odoo.models.unlink')
+    def test_mail_message_values_document_alias(self):
+        msg = self.Message.create({
+            'model': 'mail.test.container',
+            'res_id': self.alias_record.id
+        })
+        self.assertIn('-openerp-%d-mail.test' % self.alias_record.id, msg.message_id.split('@')[0])
+        reply_to_name = '%s %s' % (self.env.user.company_id.name, self.alias_record.name)
+        reply_to_email = '%s@%s' % (self.alias_record.alias_name, self.alias_domain)
+        self.assertEqual(msg.reply_to, formataddr((reply_to_name, reply_to_email)))
+        self.assertEqual(msg.email_from, formataddr((self.user_employee.name, self.user_employee.email)))
+
+        # no alias domain -> author
+        self.env['ir.config_parameter'].search([('key', '=', 'mail.catchall.domain')]).unlink()
+
+        msg = self.Message.create({
+            'model': 'mail.test.container',
+            'res_id': self.alias_record.id
+        })
+        self.assertIn('-openerp-%d-mail.test' % self.alias_record.id, msg.message_id.split('@')[0])
+        self.assertEqual(msg.reply_to, formataddr((self.user_employee.name, self.user_employee.email)))
+        self.assertEqual(msg.email_from, formataddr((self.user_employee.name, self.user_employee.email)))
+
+        # no catchall -> don't care, alias
+        self.env['ir.config_parameter'].set_param('mail.catchall.domain', self.alias_domain)
+        self.env['ir.config_parameter'].search([('key', '=', 'mail.catchall.alias')]).unlink()
+
+        msg = self.Message.create({
+            'model': 'mail.test.container',
+            'res_id': self.alias_record.id
+        })
+        self.assertIn('-openerp-%d-mail.test' % self.alias_record.id, msg.message_id.split('@')[0])
+        reply_to_name = '%s %s' % (self.env.company.name, self.alias_record.name)
+        reply_to_email = '%s@%s' % (self.alias_record.alias_name, self.alias_domain)
+        self.assertEqual(msg.reply_to, formataddr((reply_to_name, reply_to_email)))
+        self.assertEqual(msg.email_from, formataddr((self.user_employee.name, self.user_employee.email)))
+
+    @mute_logger('odoo.models.unlink')
+    def test_mail_message_values_document_no_alias(self):
+        test_record = self.env['mail.test.simple'].create({'name': 'Test', 'email_from': 'ignasse@example.com'})
+
+        msg = self.Message.create({
+            'model': 'mail.test.simple',
+            'res_id': test_record.id
+        })
+        self.assertIn('-openerp-%d-mail.test.simple' % test_record.id, msg.message_id.split('@')[0])
+        reply_to_name = '%s %s' % (self.env.user.company_id.name, test_record.name)
+        reply_to_email = '%s@%s' % (self.alias_catchall, self.alias_domain)
+        self.assertEqual(msg.reply_to, formataddr((reply_to_name, reply_to_email)))
+        self.assertEqual(msg.email_from, formataddr((self.user_employee.name, self.user_employee.email)))
+
+    @mute_logger('odoo.models.unlink')
+    def test_mail_message_values_document_manual_alias(self):
+        test_record = self.env['mail.test.simple'].create({'name': 'Test', 'email_from': 'ignasse@example.com'})
+        alias = self.env['mail.alias'].create({
+            'alias_name': 'MegaLias',
+            'alias_user_id': False,
+            'alias_model_id': self.env['ir.model']._get('mail.test.simple').id,
+            'alias_parent_model_id': self.env['ir.model']._get('mail.test.simple').id,
+            'alias_parent_thread_id': test_record.id,
+        })
+
+        msg = self.Message.create({
+            'model': 'mail.test.simple',
+            'res_id': test_record.id
+        })
+
+        self.assertIn('-openerp-%d-mail.test.simple' % test_record.id, msg.message_id.split('@')[0])
+        reply_to_name = '%s %s' % (self.env.user.company_id.name, test_record.name)
+        reply_to_email = '%s@%s' % (alias.alias_name, self.alias_domain)
+        self.assertEqual(msg.reply_to, formataddr((reply_to_name, reply_to_email)))
+        self.assertEqual(msg.email_from, formataddr((self.user_employee.name, self.user_employee.email)))
+
+    def test_mail_message_values_no_auto_thread(self):
+        msg = self.Message.create({
+            'model': 'mail.test.container',
+            'res_id': self.alias_record.id,
+            'no_auto_thread': True,
+        })
+        self.assertIn('reply_to', msg.message_id.split('@')[0])
+        self.assertNotIn('mail.test.container', msg.message_id.split('@')[0])
+        self.assertNotIn('-%d-' % self.alias_record.id, msg.message_id.split('@')[0])
+
+    def test_mail_message_base64_image(self):
+        msg = self.env['mail.message'].with_user(self.user_employee).create({
+            'body': 'taratata <img src="data:image/png;base64,iV/+OkI=" width="2"> <img src="data:image/png;base64,iV/+OkI=" width="2">',
+        })
+        self.assertEqual(len(msg.attachment_ids), 1)
+        body = '<p>taratata <img src="/web/image/%s?access_token=%s" alt="image0" width="2"> <img src="/web/image/%s?access_token=%s" alt="image0" width="2"></p>'
+        body = body % (msg.attachment_ids[0].id, msg.attachment_ids[0].access_token, msg.attachment_ids[0].id, msg.attachment_ids[0].access_token)
+        self.assertEqual(msg.body, body)
+
+
+class TestMessageAccess(TestMailCommon):
+
+    @classmethod
+    def setUpClass(cls):
+        super(TestMessageAccess, cls).setUpClass()
+
+        cls.user_public = mail_new_test_user(cls.env, login='bert', groups='base.group_public', name='Bert Tartignole')
+        cls.user_portal = mail_new_test_user(cls.env, login='chell', groups='base.group_portal', name='Chell Gladys')
+
+        Channel = cls.env['mail.channel'].with_context(cls._test_context)
+        # Pigs: base group for tests
+        cls.group_pigs = Channel.create({
+            'name': 'Pigs',
+            'public': 'groups',
+            'group_public_id': cls.env.ref('base.group_user').id})
+        # Jobs: public group
+        cls.group_public = Channel.create({
+            'name': 'Jobs',
+            'description': 'NotFalse',
+            'public': 'public'})
+        # Private: private gtroup
+        cls.group_private = Channel.create({
+            'name': 'Private',
+            'public': 'private'})
+        cls.message = cls.env['mail.message'].create({
+            'body': 'My Body',
+            'model': 'mail.channel',
+            'res_id': cls.group_private.id,
+        })
+
+    @mute_logger('odoo.addons.mail.models.mail_mail')
+    def test_mail_message_access_search(self):
+        # Data: various author_ids, partner_ids, documents
+        msg1 = self.env['mail.message'].create({
+            'subject': '_ZTest', 'body': 'A', 'subtype_id': self.ref('mail.mt_comment')})
+        msg2 = self.env['mail.message'].create({
+            'subject': '_ZTest', 'body': 'A+B', 'subtype_id': self.ref('mail.mt_comment'),
+            'partner_ids': [(6, 0, [self.user_public.partner_id.id])]})
+        msg3 = self.env['mail.message'].create({
+            'subject': '_ZTest', 'body': 'A Pigs', 'subtype_id': False,
+            'model': 'mail.channel', 'res_id': self.group_pigs.id})
+        msg4 = self.env['mail.message'].create({
+            'subject': '_ZTest', 'body': 'A+P Pigs', 'subtype_id': self.ref('mail.mt_comment'),
+            'model': 'mail.channel', 'res_id': self.group_pigs.id,
+            'partner_ids': [(6, 0, [self.user_public.partner_id.id])]})
+        msg5 = self.env['mail.message'].create({
+            'subject': '_ZTest', 'body': 'A+E Pigs', 'subtype_id': self.ref('mail.mt_comment'),
+            'model': 'mail.channel', 'res_id': self.group_pigs.id,
+            'partner_ids': [(6, 0, [self.user_employee.partner_id.id])]})
+        msg6 = self.env['mail.message'].create({
+            'subject': '_ZTest', 'body': 'A Birds', 'subtype_id': self.ref('mail.mt_comment'),
+            'model': 'mail.channel', 'res_id': self.group_private.id})
+        msg7 = self.env['mail.message'].with_user(self.user_employee).create({
+            'subject': '_ZTest', 'body': 'B', 'subtype_id': self.ref('mail.mt_comment')})
+        msg8 = self.env['mail.message'].with_user(self.user_employee).create({
+            'subject': '_ZTest', 'body': 'B+E', 'subtype_id': self.ref('mail.mt_comment'),
+            'partner_ids': [(6, 0, [self.user_employee.partner_id.id])]})
+
+        # Test: Public: 2 messages (recipient)
+        messages = self.env['mail.message'].with_user(self.user_public).search([('subject', 'like', '_ZTest')])
+        self.assertEqual(messages, msg2 | msg4)
+
+        # Test: Employee: 3 messages on Pigs Raoul can read (employee can read group with default values)
+        messages = self.env['mail.message'].with_user(self.user_employee).search([('subject', 'like', '_ZTest'), ('body', 'ilike', 'A')])
+        self.assertEqual(messages, msg3 | msg4 | msg5)
+
+        # Test: Raoul: 3 messages on Pigs Raoul can read (employee can read group with default values), 0 on Birds (private group) + 2 messages as author
+        messages = self.env['mail.message'].with_user(self.user_employee).search([('subject', 'like', '_ZTest')])
+        self.assertEqual(messages, msg3 | msg4 | msg5 | msg7 | msg8)
+
+        # Test: Admin: all messages
+        messages = self.env['mail.message'].search([('subject', 'like', '_ZTest')])
+        self.assertEqual(messages, msg1 | msg2 | msg3 | msg4 | msg5 | msg6 | msg7 | msg8)
+
+        # Test: Portal: 0 (no access to groups, not recipient)
+        messages = self.env['mail.message'].with_user(self.user_portal).search([('subject', 'like', '_ZTest')])
+        self.assertFalse(messages)
+
+        # Test: Portal: 2 messages (public group with a subtype)
+        self.group_pigs.write({'public': 'public'})
+        messages = self.env['mail.message'].with_user(self.user_portal).search([('subject', 'like', '_ZTest')])
+        self.assertEqual(messages, msg4 | msg5)
+
+    # --------------------------------------------------
+    # READ
+    # --------------------------------------------------
+
+    @mute_logger('odoo.addons.base.models.ir_model', 'odoo.models')
+    def test_mail_message_access_read_crash(self):
+        with self.assertRaises(AccessError):
+            self.message.with_user(self.user_employee).read()
+
+    @mute_logger('odoo.models')
+    def test_mail_message_access_read_crash_portal(self):
+        with self.assertRaises(AccessError):
+            self.message.with_user(self.user_portal).read(['body', 'message_type', 'subtype_id'])
+
+    def test_mail_message_access_read_ok_portal(self):
+        self.message.write({'subtype_id': self.ref('mail.mt_comment'), 'res_id': self.group_public.id})
+        self.message.with_user(self.user_portal).read(['body', 'message_type', 'subtype_id'])
+
+    def test_mail_message_access_read_notification(self):
+        attachment = self.env['ir.attachment'].create({
+            'datas': base64.b64encode(b'My attachment'),
+            'name': 'doc.txt'})
+        # attach the attachment to the message
+        self.message.write({'attachment_ids': [(4, attachment.id)]})
+        self.message.write({'partner_ids': [(4, self.user_employee.partner_id.id)]})
+        self.message.with_user(self.user_employee).read()
+        # Test: Bert has access to attachment, ok because he can read message
+        attachment.with_user(self.user_employee).read(['name', 'datas'])
+
+    def test_mail_message_access_read_author(self):
+        self.message.write({'author_id': self.user_employee.partner_id.id})
+        self.message.with_user(self.user_employee).read()
+
+    def test_mail_message_access_read_doc(self):
+        self.message.write({'model': 'mail.channel', 'res_id': self.group_public.id})
+        # Test: Bert reads the message, ok because linked to a doc he is allowed to read
+        self.message.with_user(self.user_employee).read()
+
+    def test_mail_message_access_read_crash_moderation(self):
+        # with self.assertRaises(AccessError):
+        self.message.write({'model': 'mail.channel', 'res_id': self.group_public.id, 'moderation_status': 'pending_moderation'})
+        # Test: Bert reads the message, ok because linked to a doc he is allowed to read
+        self.message.with_user(self.user_employee).read()
+
+    # --------------------------------------------------
+    # CREATE
+    # --------------------------------------------------
+
+    @mute_logger('odoo.addons.base.models.ir_model')
+    def test_mail_message_access_create_crash_public(self):
+        # Do: Bert creates a message on Pigs -> ko, no creation rights
+        with self.assertRaises(AccessError):
+            self.env['mail.message'].with_user(self.user_public).create({'model': 'mail.channel', 'res_id': self.group_pigs.id, 'body': 'Test'})
+
+        # Do: Bert create a message on Jobs -> ko, no creation rights
+        with self.assertRaises(AccessError):
+            self.env['mail.message'].with_user(self.user_public).create({'model': 'mail.channel', 'res_id': self.group_public.id, 'body': 'Test'})
+
+    @mute_logger('odoo.models')
+    def test_mail_message_access_create_crash(self):
+        # Do: Bert create a private message -> ko, no creation rights
+        with self.assertRaises(AccessError):
+            self.env['mail.message'].with_user(self.user_employee).create({'model': 'mail.channel', 'res_id': self.group_private.id, 'body': 'Test'})
+
+    @mute_logger('odoo.models')
+    def test_mail_message_access_create_doc(self):
+        Message = self.env['mail.message'].with_user(self.user_employee)
+        # Do: Raoul creates a message on Jobs -> ok, write access to the related document
+        Message.create({'model': 'mail.channel', 'res_id': self.group_public.id, 'body': 'Test'})
+        # Do: Raoul creates a message on Priv -> ko, no write access to the related document
+        with self.assertRaises(AccessError):
+            Message.create({'model': 'mail.channel', 'res_id': self.group_private.id, 'body': 'Test'})
+
+    def test_mail_message_access_create_private(self):
+        self.env['mail.message'].with_user(self.user_employee).create({'body': 'Test'})
+
+    def test_mail_message_access_create_reply(self):
+        # TDE FIXME: should it really work ? not sure - catchall makes crash (aka, post will crash also)
+        self.env['ir.config_parameter'].set_param('mail.catchall.domain', False)
+        self.message.write({'partner_ids': [(4, self.user_employee.partner_id.id)]})
+        self.env['mail.message'].with_user(self.user_employee).create({'model': 'mail.channel', 'res_id': self.group_private.id, 'body': 'Test', 'parent_id': self.message.id})
+
+    def test_mail_message_access_create_wo_parent_access(self):
+        """ Purpose is to test posting a message on a record whose first message / parent
+        is not accessible by current user. """
+        test_record = self.env['mail.test.simple'].with_context(self._test_context).create({'name': 'Test', 'email_from': 'ignasse@example.com'})
+        partner_1 = self.env['res.partner'].create({
+            'name': 'Jitendra Prajapati (jpr-odoo)',
+            'email': 'jpr@odoo.com',
+        })
+        test_record.message_subscribe((partner_1 | self.user_admin.partner_id).ids)
+
+        message = test_record.message_post(
+            body='<p>This is First Message</p>', subject='Subject',
+            message_type='comment', subtype_xmlid='mail.mt_note')
+        # portal user have no rights to read the message
+        with self.assertRaises(AccessError):
+            message.with_user(self.user_portal).read(['subject, body'])
+
+        with patch.object(MailTestSimple, 'check_access_rights', return_value=True):
+            with self.assertRaises(AccessError):
+                message.with_user(self.user_portal).read(['subject, body'])
+
+            # parent message is accessible to references notification mail values
+            # for _notify method and portal user have no rights to send the message for this model
+            new_msg = test_record.with_user(self.user_portal).message_post(
+                body='<p>This is Second Message</p>',
+                subject='Subject',
+                parent_id=message.id,
+                message_type='comment',
+                subtype_xmlid='mail.mt_comment',
+                mail_auto_delete=False)
+
+        new_mail = self.env['mail.mail'].sudo().search([
+            ('mail_message_id', '=', new_msg.id),
+            ('references', '=', message.message_id),
+        ])
+
+        self.assertTrue(new_mail)
+        self.assertEqual(new_msg.parent_id, message)
+
+    # --------------------------------------------------
+    # WRITE
+    # --------------------------------------------------
+
+    def test_mail_message_access_write_moderation(self):
+        """ Only moderators can modify pending messages """
+        self.group_public.write({
+            'email_send': True,
+            'moderation': True,
+            'channel_partner_ids': [(4, self.partner_employee.id)],
+            'moderator_ids': [(4, self.user_employee.id)],
+        })
+        self.message.write({'model': 'mail.channel', 'res_id': self.group_public.id, 'moderation_status': 'pending_moderation'})
+        self.message.with_user(self.user_employee).write({'moderation_status': 'accepted'})
+
+    def test_mail_message_access_write_crash_moderation(self):
+        self.message.write({'model': 'mail.channel', 'res_id': self.group_public.id, 'moderation_status': 'pending_moderation'})
+        with self.assertRaises(AccessError):
+            self.message.with_user(self.user_employee).write({'moderation_status': 'accepted'})
+
+    @mute_logger('openerp.addons.mail.models.mail_mail')
+    def test_mark_all_as_read(self):
+        self.user_employee.notification_type = 'inbox'
+        emp_partner = self.user_employee.partner_id.with_user(self.user_employee)
+
+        group_private = self.env['mail.channel'].with_context({
+            'mail_create_nolog': True,
+            'mail_create_nosubscribe': True,
+            'mail_channel_noautofollow': True,
+        }).create({
+            'name': 'Private',
+            'description': 'Private James R.',
+            'public': 'private',
+            'alias_name': 'private',
+            'alias_contact': 'followers'}
+        ).with_context({'mail_create_nosubscribe': False})
+
+        # mark all as read clear needactions
+        msg1 = group_private.message_post(body='Test', message_type='comment', subtype_xmlid='mail.mt_comment', partner_ids=[emp_partner.id])
+        self._reset_bus()
+        emp_partner.env['mail.message'].mark_all_as_read(domain=[])
+        self.assertBusNotifications([(self.cr.dbname, 'res.partner', emp_partner.id)], [{ 'type': 'mark_as_read', 'message_ids': [msg1.id], 'needaction_inbox_counter': 0 }])
+        na_count = emp_partner.get_needaction_count()
+        self.assertEqual(na_count, 0, "mark all as read should conclude all needactions")
+
+        # mark all as read also clear inaccessible needactions
+        msg2 = group_private.message_post(body='Zest', message_type='comment', subtype_xmlid='mail.mt_comment', partner_ids=[emp_partner.id])
+        needaction_accessible = len(emp_partner.env['mail.message'].search([['needaction', '=', True]]))
+        self.assertEqual(needaction_accessible, 1, "a new message to a partner is readable to that partner")
+
+        msg2.sudo().partner_ids = self.env['res.partner']
+        emp_partner.env['mail.message'].search([['needaction', '=', True]])
+        needaction_length = len(emp_partner.env['mail.message'].search([['needaction', '=', True]]))
+        self.assertEqual(needaction_length, 1, "message should still be readable when notified")
+
+        na_count = emp_partner.get_needaction_count()
+        self.assertEqual(na_count, 1, "message not accessible is currently still counted")
+
+        self._reset_bus()
+        emp_partner.env['mail.message'].mark_all_as_read(domain=[])
+        self.assertBusNotifications([(self.cr.dbname, 'res.partner', emp_partner.id)], [{ 'type': 'mark_as_read', 'message_ids': [msg2.id], 'needaction_inbox_counter': 0 }])
+        na_count = emp_partner.get_needaction_count()
+        self.assertEqual(na_count, 0, "mark all read should conclude all needactions even inacessible ones")
+
+    @mute_logger('openerp.addons.mail.models.mail_mail')
+    def test_mark_all_as_read_share(self):
+        self.user_portal.notification_type = 'inbox'
+        portal_partner = self.user_portal.partner_id.with_user(self.user_portal)
+
+        # mark all as read clear needactions
+        self.group_pigs.message_post(body='Test', message_type='comment', subtype_xmlid='mail.mt_comment', partner_ids=[portal_partner.id])
+        portal_partner.env['mail.message'].mark_all_as_read(domain=[])
+        na_count = portal_partner.get_needaction_count()
+        self.assertEqual(na_count, 0, "mark all as read should conclude all needactions")
+
+        # mark all as read also clear inaccessible needactions
+        new_msg = self.group_pigs.message_post(body='Zest', message_type='comment', subtype_xmlid='mail.mt_comment', partner_ids=[portal_partner.id])
+        needaction_accessible = len(portal_partner.env['mail.message'].search([['needaction', '=', True]]))
+        self.assertEqual(needaction_accessible, 1, "a new message to a partner is readable to that partner")
+
+        new_msg.sudo().partner_ids = self.env['res.partner']
+        needaction_length = len(portal_partner.env['mail.message'].search([['needaction', '=', True]]))
+        self.assertEqual(needaction_length, 1, "message should still be readable when notified")
+
+        na_count = portal_partner.get_needaction_count()
+        self.assertEqual(na_count, 1, "message not accessible is currently still counted")
+
+        portal_partner.env['mail.message'].mark_all_as_read(domain=[])
+        na_count = portal_partner.get_needaction_count()
+        self.assertEqual(na_count, 0, "mark all read should conclude all needactions even inacessible ones")
+
+
+@tagged('moderation')
+class TestMessageModeration(TestMailCommon):
+
+    @classmethod
+    def setUpClass(cls):
+        super(TestMessageModeration, cls).setUpClass()
+
+        cls.channel_1 = cls.env['mail.channel'].create({
+            'name': 'Moderation_1',
+            'email_send': True,
+            'moderation': True
+        })
+        cls.user_employee.write({'moderation_channel_ids': [(6, 0, [cls.channel_1.id])]})
+        cls.user_portal = cls._create_portal_user()
+
+        # A pending moderation message needs to have field channel_ids empty. Moderators
+        # need to be able to notify a pending moderation message (in a channel they moderate).
+        cls.msg_c1_admin1 = cls._add_messages(cls.channel_1, 'Body11', author=cls.partner_admin, moderation_status='pending_moderation')
+        cls.msg_c1_admin2 = cls._add_messages(cls.channel_1, 'Body12', author=cls.partner_admin, moderation_status='pending_moderation')
+        cls.msg_c1_portal = cls._add_messages(cls.channel_1, 'Body21', author=cls.partner_portal, moderation_status='pending_moderation')
+
+    @mute_logger('odoo.models.unlink')
+    def test_moderate_accept(self):
+        self._reset_bus()
+        self.assertFalse(self.msg_c1_admin1.channel_ids | self.msg_c1_admin2.channel_ids | self.msg_c1_portal.channel_ids)
+
+        self.msg_c1_admin1.with_user(self.user_employee)._moderate('accept')
+        self.assertEqual(self.msg_c1_admin1.channel_ids, self.channel_1)
+        self.assertEqual(self.msg_c1_admin1.moderation_status, 'accepted')
+        self.assertEqual(self.msg_c1_admin2.moderation_status, 'pending_moderation')
+        self.assertBusNotifications([(self.cr.dbname, 'mail.channel', self.channel_1.id)])
+
+    @mute_logger('odoo.models.unlink')
+    def test_moderate_allow(self):
+        self._reset_bus()
+
+        self.msg_c1_admin1.with_user(self.user_employee)._moderate('allow')
+        self.assertEqual(self.msg_c1_admin1.channel_ids, self.channel_1)
+        self.assertEqual(self.msg_c1_admin2.channel_ids, self.channel_1)
+        self.assertEqual(self.msg_c1_admin1.moderation_status, 'accepted')
+        self.assertEqual(self.msg_c1_admin2.moderation_status, 'accepted')
+        self.assertBusNotifications([
+            (self.cr.dbname, 'mail.channel', self.channel_1.id),
+            (self.cr.dbname, 'mail.channel', self.channel_1.id)])
+
+    @mute_logger('odoo.models.unlink')
+    def test_moderate_reject(self):
+        with self.mock_mail_gateway():
+            (self.msg_c1_admin1 | self.msg_c1_portal).with_user(self.user_employee)._moderate_send_reject_email('Title', 'Message to author')
+            self.assertEqual(len(self._new_mails), 2)
+        for mail in self._new_mails:
+            self.assertEqual(mail.author_id, self.partner_employee)
+            self.assertEqual(mail.subject, 'Title')
+            self.assertEqual(mail.state, 'outgoing')
+        self.assertEqual(
+            set(self._new_mails.mapped('email_to')),
+            set([self.msg_c1_admin1.email_from, self.msg_c1_portal.email_from])
+        )
+        self.assertEqual(
+            set(self._new_mails.mapped('body_html')),
+            set(['<div>Message to author</div>\n%s\n' % self.msg_c1_admin1.body, '<div>Message to author</div>\n%s\n' % self.msg_c1_portal.body])
+        )  # TDE note: \n are added by append content to html, because why not
+
+    @mute_logger('odoo.models.unlink')
+    def test_moderate_discard(self):
+        self._reset_bus()
+        id1, id2, id3 = self.msg_c1_admin1.id, self.msg_c1_admin2.id, self.msg_c1_portal.id  # save ids because unlink will discard them
+        (self.msg_c1_admin1 | self.msg_c1_admin2 | self.msg_c1_portal).with_user(self.user_employee)._moderate_discard()
+
+        self.assertBusNotifications(
+            [(self.cr.dbname, 'res.partner', self.partner_admin.id),
+             (self.cr.dbname, 'res.partner', self.partner_employee.id),
+             (self.cr.dbname, 'res.partner', self.partner_portal.id)],
+            [{'type': 'deletion', 'message_ids': [id1, id2]},  # author of 2 messages
+             {'type': 'deletion', 'message_ids': [id1, id2, id3]},  # moderator
+             {'type': 'deletion', 'message_ids': [id3]}]  # author of 1 message
+        )
+
+    @mute_logger('odoo.models.unlink')
+    def test_notify_moderators(self):
+        # create pending messages in another channel to have two notification to push
+        channel_2 = self.env['mail.channel'].create({
+            'name': 'Moderation_1',
+            'email_send': True,
+            'moderation': True
+        })
+        self.user_admin.write({'moderation_channel_ids': [(6, 0, [channel_2.id])]})
+        self.msg_c2_portal = self._add_messages(channel_2, 'Body31', author=self.partner_portal, moderation_status='pending_moderation')
+
+        # one notification for each moderator: employee (channel1), admin (channel2)
+        with self.assertPostNotifications([{
+            'content': 'Hello %s' % self.partner_employee.name,
+            'message_type': 'user_notification', 'subtype': 'mail.mt_note',
+            'notif': [{
+                'partner': self.partner_employee,
+                'type': 'inbox'}]
+        }, {
+            'content': 'Hello %s' % self.partner_admin.name,
+            'message_type': 'user_notification', 'subtype': 'mail.mt_note',
+            'notif': [{
+                'partner': self.partner_admin,
+                'type': 'inbox'}]
+        }]):
+            self.env['mail.message']._notify_moderators()
diff --git a/addons/test_mail/tests/test_mail_template.py b/addons/test_mail/tests/test_mail_template.py
new file mode 100644
index 00000000..5bf72f3d
--- /dev/null
+++ b/addons/test_mail/tests/test_mail_template.py
@@ -0,0 +1,169 @@
+# -*- coding: utf-8 -*-
+# Part of Odoo. See LICENSE file for full copyright and licensing details.
+
+import base64
+
+from odoo.addons.test_mail.tests.common import TestMailCommon, TestRecipients
+from odoo.tools import mute_logger
+
+
+class TestMailTemplate(TestMailCommon, TestRecipients):
+
+    @classmethod
+    def setUpClass(cls):
+        super(TestMailTemplate, cls).setUpClass()
+        cls.test_record = cls.env['mail.test.simple'].with_context(cls._test_context).create({'name': 'Test', 'email_from': 'ignasse@example.com'})
+
+        cls.user_employee.write({
+            'groups_id': [(4, cls.env.ref('base.group_partner_manager').id)],
+        })
+
+        cls._attachments = [{
+            'name': 'first.txt',
+            'datas': base64.b64encode(b'My first attachment'),
+            'res_model': 'res.partner',
+            'res_id': cls.user_admin.partner_id.id
+        }, {
+            'name': 'second.txt',
+            'datas': base64.b64encode(b'My second attachment'),
+            'res_model': 'res.partner',
+            'res_id': cls.user_admin.partner_id.id
+        }]
+
+        cls.email_1 = 'test1@example.com'
+        cls.email_2 = 'test2@example.com'
+        cls.email_3 = cls.partner_1.email
+        cls._create_template('mail.test.simple', {
+            'attachment_ids': [(0, 0, cls._attachments[0]), (0, 0, cls._attachments[1])],
+            'partner_to': '%s,%s' % (cls.partner_2.id, cls.user_admin.partner_id.id),
+            'email_to': '%s, %s' % (cls.email_1, cls.email_2),
+            'email_cc': '%s' % cls.email_3,
+        })
+
+        # admin should receive emails
+        cls.user_admin.write({'notification_type': 'email'})
+        # Force the attachments of the template to be in the natural order.
+        cls.email_template.invalidate_cache(['attachment_ids'], ids=cls.email_template.ids)
+
+    @mute_logger('odoo.addons.mail.models.mail_mail')
+    def test_template_send_email(self):
+        mail_id = self.email_template.send_mail(self.test_record.id)
+        mail = self.env['mail.mail'].sudo().browse(mail_id)
+        self.assertEqual(mail.subject, 'About %s' % self.test_record.name)
+        self.assertEqual(mail.email_to, self.email_template.email_to)
+        self.assertEqual(mail.email_cc, self.email_template.email_cc)
+        self.assertEqual(mail.recipient_ids, self.partner_2 | self.user_admin.partner_id)
+
+    @mute_logger('odoo.addons.mail.models.mail_mail')
+    def test_template_translation(self):
+        self.env['res.lang']._activate_lang('es_ES')
+        self.env.ref('base.module_base')._update_translations(['es_ES'])
+
+        partner = self.env['res.partner'].create({'name': "test", 'lang': 'es_ES'})
+        email_template = self.env['mail.template'].create({
+            'name': 'TestTemplate',
+            'subject': 'English Subject',
+            'body_html': '<p>English Body</p>',
+            'model_id': self.env['ir.model']._get(partner._name).id,
+            'lang': '${object.lang}'
+        })
+        # Make sure Spanish translations have not been altered
+        description_translations = self.env['ir.translation'].search([('module', '=', 'base'), ('src', '=', partner._description), ('lang', '=', 'es_ES')])
+        description_translations.update({'value': 'Spanish description'})
+
+        self.env['ir.translation'].create({
+            'type': 'model',
+            'name': 'mail.template,subject',
+            'module': 'mail',
+            'lang': 'es_ES',
+            'res_id': email_template.id,
+            'value': 'Spanish Subject',
+            'state': 'translated',
+        })
+        self.env['ir.translation'].create({
+            'type': 'model',
+            'name': 'mail.template,body_html',
+            'module': 'mail',
+            'lang': 'es_ES',
+            'res_id': email_template.id,
+            'value': '<p>Spanish Body</p>',
+            'state': 'translated',
+        })
+        view = self.env['ir.ui.view'].create({
+            'name': 'test_layout',
+            'key': 'test_layout',
+            'type': 'qweb',
+            'arch_db': '<body><t t-raw="message.body"/> English Layout <t t-esc="model_description"/></body>'
+        })
+        self.env['ir.model.data'].create({
+            'name': 'test_layout',
+            'module': 'test_mail',
+            'model': 'ir.ui.view',
+            'res_id': view.id
+        })
+        self.env['ir.translation'].create({
+            'type': 'model_terms',
+            'name': 'ir.ui.view,arch_db',
+            'module': 'test_mail',
+            'lang': 'es_ES',
+            'res_id': view.id,
+            'src': 'English Layout',
+            'value': 'Spanish Layout',
+            'state': 'translated',
+        })
+
+        mail_id = email_template.send_mail(partner.id, notif_layout='test_mail.test_layout')
+        mail = self.env['mail.mail'].sudo().browse(mail_id)
+        self.assertEqual(mail.subject, 'Spanish Subject')
+        self.assertEqual(mail.body_html, '<body><p>Spanish Body</p> Spanish Layout Spanish description</body>')
+
+    def test_template_add_context_action(self):
+        self.email_template.create_action()
+
+        # check template act_window has been updated
+        self.assertTrue(bool(self.email_template.ref_ir_act_window))
+
+        # check those records
+        action = self.email_template.ref_ir_act_window
+        self.assertEqual(action.name, 'Send Mail (%s)' % self.email_template.name)
+        self.assertEqual(action.binding_model_id.model, 'mail.test.simple')
+
+    # def test_template_scheduled_date(self):
+    #     from unittest.mock import patch
+
+    #     self.email_template_in_2_days = self.email_template.copy()
+
+    #     with patch('odoo.addons.mail.tests.test_mail_template.datetime', wraps=datetime) as mock_datetime:
+    #         mock_datetime.now.return_value = datetime(2017, 11, 15, 11, 30, 28)
+    #         mock_datetime.side_effect = lambda *args, **kw: datetime(*args, **kw)
+
+    #         self.email_template_in_2_days.write({
+    #             'scheduled_date': "${(datetime.datetime.now() + relativedelta(days=2)).strftime('%s')}" % DEFAULT_SERVER_DATETIME_FORMAT,
+    #         })
+
+    #         mail_now_id = self.email_template.send_mail(self.test_record.id)
+    #         mail_in_2_days_id = self.email_template_in_2_days.send_mail(self.test_record.id)
+
+    #         mail_now = self.env['mail.mail'].browse(mail_now_id)
+    #         mail_in_2_days = self.env['mail.mail'].browse(mail_in_2_days_id)
+
+    #         # mail preparation
+    #         self.assertEqual(mail_now.exists() | mail_in_2_days.exists(), mail_now | mail_in_2_days)
+    #         self.assertEqual(bool(mail_now.scheduled_date), False)
+    #         self.assertEqual(mail_now.state, 'outgoing')
+    #         self.assertEqual(mail_in_2_days.state, 'outgoing')
+    #         scheduled_date = datetime.strptime(mail_in_2_days.scheduled_date, DEFAULT_SERVER_DATETIME_FORMAT)
+    #         date_in_2_days = datetime.now() + timedelta(days = 2)
+    #         self.assertEqual(scheduled_date, date_in_2_days)
+    #         # self.assertEqual(scheduled_date.month, date_in_2_days.month)
+    #         # self.assertEqual(scheduled_date.year, date_in_2_days.year)
+
+    #         # Launch the scheduler on the first mail, it should be reported in self.mails
+    #         # and the mail_mail is now deleted
+    #         self.env['mail.mail'].process_email_queue()
+    #         self.assertEqual(mail_now.exists() | mail_in_2_days.exists(), mail_in_2_days)
+
+    #         # Launch the scheduler on the first mail, it's still in 'outgoing' state
+    #         self.env['mail.mail'].process_email_queue(ids=[mail_in_2_days.id])
+    #         self.assertEqual(mail_in_2_days.state, 'outgoing')
+    #         self.assertEqual(mail_now.exists() | mail_in_2_days.exists(), mail_in_2_days)
diff --git a/addons/test_mail/tests/test_mail_thread_internals.py b/addons/test_mail/tests/test_mail_thread_internals.py
new file mode 100644
index 00000000..afdf2522
--- /dev/null
+++ b/addons/test_mail/tests/test_mail_thread_internals.py
@@ -0,0 +1,253 @@
+# -*- coding: utf-8 -*-
+# Part of Odoo. See LICENSE file for full copyright and licensing details.
+
+from werkzeug.urls import url_parse, url_decode
+
+from odoo.addons.test_mail.tests.common import TestMailCommon, TestRecipients
+from odoo.tests.common import tagged, HttpCase
+from odoo.tools import mute_logger
+
+
+class TestChatterTweaks(TestMailCommon, TestRecipients):
+
+    @classmethod
+    def setUpClass(cls):
+        super(TestChatterTweaks, cls).setUpClass()
+        cls.test_record = cls.env['mail.test.simple'].with_context(cls._test_context).create({'name': 'Test', 'email_from': 'ignasse@example.com'})
+
+    def test_post_no_subscribe_author(self):
+        original = self.test_record.message_follower_ids
+        self.test_record.with_user(self.user_employee).with_context({'mail_create_nosubscribe': True}).message_post(
+            body='Test Body', message_type='comment', subtype_xmlid='mail.mt_comment')
+        self.assertEqual(self.test_record.message_follower_ids.mapped('partner_id'), original.mapped('partner_id'))
+        self.assertEqual(self.test_record.message_follower_ids.mapped('channel_id'), original.mapped('channel_id'))
+
+    @mute_logger('odoo.addons.mail.models.mail_mail')
+    def test_post_no_subscribe_recipients(self):
+        original = self.test_record.message_follower_ids
+        self.test_record.with_user(self.user_employee).with_context({'mail_create_nosubscribe': True}).message_post(
+            body='Test Body', message_type='comment', subtype_xmlid='mail.mt_comment', partner_ids=[self.partner_1.id, self.partner_2.id])
+        self.assertEqual(self.test_record.message_follower_ids.mapped('partner_id'), original.mapped('partner_id'))
+        self.assertEqual(self.test_record.message_follower_ids.mapped('channel_id'), original.mapped('channel_id'))
+
+    @mute_logger('odoo.addons.mail.models.mail_mail')
+    def test_post_subscribe_recipients(self):
+        original = self.test_record.message_follower_ids
+        self.test_record.with_user(self.user_employee).with_context({'mail_create_nosubscribe': True, 'mail_post_autofollow': True}).message_post(
+            body='Test Body', message_type='comment', subtype_xmlid='mail.mt_comment', partner_ids=[self.partner_1.id, self.partner_2.id])
+        self.assertEqual(self.test_record.message_follower_ids.mapped('partner_id'), original.mapped('partner_id') | self.partner_1 | self.partner_2)
+        self.assertEqual(self.test_record.message_follower_ids.mapped('channel_id'), original.mapped('channel_id'))
+
+    def test_chatter_mail_create_nolog(self):
+        """ Test disable of automatic chatter message at create """
+        rec = self.env['mail.test.simple'].with_user(self.user_employee).with_context({'mail_create_nolog': True}).create({'name': 'Test'})
+        self.flush_tracking()
+        self.assertEqual(rec.message_ids, self.env['mail.message'])
+
+        rec = self.env['mail.test.simple'].with_user(self.user_employee).with_context({'mail_create_nolog': False}).create({'name': 'Test'})
+        self.flush_tracking()
+        self.assertEqual(len(rec.message_ids), 1)
+
+    def test_chatter_mail_notrack(self):
+        """ Test disable of automatic value tracking at create and write """
+        rec = self.env['mail.test.track'].with_user(self.user_employee).create({'name': 'Test', 'user_id': self.user_employee.id})
+        self.flush_tracking()
+        self.assertEqual(len(rec.message_ids), 1,
+                         "A creation message without tracking values should have been posted")
+        self.assertEqual(len(rec.message_ids.sudo().tracking_value_ids), 0,
+                         "A creation message without tracking values should have been posted")
+
+        rec.with_context({'mail_notrack': True}).write({'user_id': self.user_admin.id})
+        self.flush_tracking()
+        self.assertEqual(len(rec.message_ids), 1,
+                         "No new message should have been posted with mail_notrack key")
+
+        rec.with_context({'mail_notrack': False}).write({'user_id': self.user_employee.id})
+        self.flush_tracking()
+        self.assertEqual(len(rec.message_ids), 2,
+                         "A tracking message should have been posted")
+        self.assertEqual(len(rec.message_ids.sudo().mapped('tracking_value_ids')), 1,
+                         "New tracking message should have tracking values")
+
+    def test_chatter_tracking_disable(self):
+        """ Test disable of all chatter features at create and write """
+        rec = self.env['mail.test.track'].with_user(self.user_employee).with_context({'tracking_disable': True}).create({'name': 'Test', 'user_id': self.user_employee.id})
+        self.flush_tracking()
+        self.assertEqual(rec.sudo().message_ids, self.env['mail.message'])
+        self.assertEqual(rec.sudo().mapped('message_ids.tracking_value_ids'), self.env['mail.tracking.value'])
+
+        rec.write({'user_id': self.user_admin.id})
+        self.flush_tracking()
+        self.assertEqual(rec.sudo().mapped('message_ids.tracking_value_ids'), self.env['mail.tracking.value'])
+
+        rec.with_context({'tracking_disable': False}).write({'user_id': self.user_employee.id})
+        self.flush_tracking()
+        self.assertEqual(len(rec.sudo().mapped('message_ids.tracking_value_ids')), 1)
+
+        rec = self.env['mail.test.track'].with_user(self.user_employee).with_context({'tracking_disable': False}).create({'name': 'Test', 'user_id': self.user_employee.id})
+        self.flush_tracking()
+        self.assertEqual(len(rec.sudo().message_ids), 1,
+                         "Creation message without tracking values should have been posted")
+        self.assertEqual(len(rec.sudo().mapped('message_ids.tracking_value_ids')), 0,
+                         "Creation message without tracking values should have been posted")
+
+    def test_cache_invalidation(self):
+        """ Test that creating a mail-thread record does not invalidate the whole cache. """
+        # make a new record in cache
+        record = self.env['res.partner'].new({'name': 'Brave New Partner'})
+        self.assertTrue(record.name)
+
+        # creating a mail-thread record should not invalidate the whole cache
+        self.env['res.partner'].create({'name': 'Actual Partner'})
+        self.assertTrue(record.name)
+
+
+class TestDiscuss(TestMailCommon, TestRecipients):
+
+    @classmethod
+    def setUpClass(cls):
+        super(TestDiscuss, cls).setUpClass()
+        cls.test_record = cls.env['mail.test.simple'].with_context(cls._test_context).create({'name': 'Test', 'email_from': 'ignasse@example.com'})
+
+    def test_set_message_done_user(self):
+        with self.assertSinglePostNotifications([{'partner': self.partner_employee, 'type': 'inbox'}], message_info={'content': 'Test'}):
+            message = self.test_record.message_post(
+                body='Test', message_type='comment', subtype_xmlid='mail.mt_comment',
+                partner_ids=[self.user_employee.partner_id.id])
+        message.with_user(self.user_employee).set_message_done()
+        self.assertMailNotifications(message, [{'notif': [{'partner': self.partner_employee, 'type': 'inbox', 'is_read': True}]}])
+        # TDE TODO: it seems bus notifications could be checked
+
+    def test_set_star(self):
+        msg = self.test_record.with_user(self.user_admin).message_post(body='My Body', subject='1')
+        msg_emp = self.env['mail.message'].with_user(self.user_employee).browse(msg.id)
+
+        # Admin set as starred
+        msg.toggle_message_starred()
+        self.assertTrue(msg.starred)
+
+        # Employee set as starred
+        msg_emp.toggle_message_starred()
+        self.assertTrue(msg_emp.starred)
+
+        # Do: Admin unstars msg
+        msg.toggle_message_starred()
+        self.assertFalse(msg.starred)
+        self.assertTrue(msg_emp.starred)
+
+    @mute_logger('odoo.addons.mail.models.mail_mail')
+    def test_mail_cc_recipient_suggestion(self):
+        record = self.env['mail.test.cc'].create({'email_cc': 'cc1@example.com, cc2@example.com, cc3 <cc3@example.com>'})
+        suggestions = record._message_get_suggested_recipients()[record.id]
+        self.assertEqual(sorted(suggestions), [
+            (False, '"cc3" <cc3@example.com>', 'CC Email'),
+            (False, 'cc1@example.com', 'CC Email'),
+            (False, 'cc2@example.com', 'CC Email'),
+        ], 'cc should be in suggestions')
+
+    def test_inbox_message_fetch_needaction(self):
+        user1 = self.env['res.users'].create({'login': 'user1', 'name': 'User 1'})
+        user1.notification_type = 'inbox'
+        user2 = self.env['res.users'].create({'login': 'user2', 'name': 'User 2'})
+        user2.notification_type = 'inbox'
+        message1 = self.test_record.with_user(self.user_admin).message_post(body='Message 1', partner_ids=[user1.partner_id.id, user2.partner_id.id])
+        message2 = self.test_record.with_user(self.user_admin).message_post(body='Message 2', partner_ids=[user1.partner_id.id, user2.partner_id.id])
+
+        # both notified users should have the 2 messages in Inbox initially
+        messages = self.env['mail.message'].with_user(user1).message_fetch(domain=[['needaction', '=', True]])
+        self.assertEqual(len(messages), 2)
+        messages = self.env['mail.message'].with_user(user2).message_fetch(domain=[['needaction', '=', True]])
+        self.assertEqual(len(messages), 2)
+
+        # first user is marking one message as done: the other message is still Inbox, while the other user still has the 2 messages in Inbox
+        message1.with_user(user1).set_message_done()
+        messages = self.env['mail.message'].with_user(user1).message_fetch(domain=[['needaction', '=', True]])
+        self.assertEqual(len(messages), 1)
+        self.assertEqual(messages[0].get('id'), message2.id)
+        messages = self.env['mail.message'].with_user(user2).message_fetch(domain=[['needaction', '=', True]])
+        self.assertEqual(len(messages), 2)
+
+    def test_notification_has_error_filter(self):
+        """Ensure message_has_error filter is only returning threads for which
+        the current user is author of a failed message."""
+        message = self.test_record.with_user(self.user_admin).message_post(
+            body='Test', message_type='comment', subtype_xmlid='mail.mt_comment',
+            partner_ids=[self.user_employee.partner_id.id]
+        )
+        self.assertFalse(message.has_error)
+        with self.mock_mail_gateway(sim_error='connect_smtp_notfound'):
+            self.user_admin.notification_type = 'email'
+            message2 = self.test_record.with_user(self.user_employee).message_post(
+                body='Test', message_type='comment', subtype_xmlid='mail.mt_comment',
+                partner_ids=[self.user_admin.partner_id.id]
+            )
+            self.assertTrue(message2.has_error)
+        # employee is author of message which has a failure
+        threads_employee = self.test_record.with_user(self.user_employee).search([('message_has_error', '=', True)])
+        self.assertEqual(len(threads_employee), 1)
+        # admin is also author of a message, but it doesn't have a failure
+        # and the failure from employee's message should not be taken into account for admin
+        threads_admin = self.test_record.with_user(self.user_admin).search([('message_has_error', '=', True)])
+        self.assertEqual(len(threads_admin), 0)
+
+
+@tagged('-at_install', 'post_install')
+class TestMultiCompany(HttpCase):
+
+    def test_redirect_to_records(self):
+
+        self.company_A = self.env['res.company'].create({
+            'name': 'Company A',
+            'user_ids': [(4, self.ref('base.user_admin'))],
+        })
+
+        self.company_B = self.env['res.company'].create({
+            'name': 'Company B',
+        })
+
+        self.multi_company_record = self.env['mail.test.multi.company'].create({
+            'name': 'Multi Company Record',
+            'company_id': self.company_A.id,
+        })
+
+        # Test Case 0
+        # Not logged, redirect to web/login
+        response = self.url_open('/mail/view?model=%s&res_id=%s' % (
+            self.multi_company_record._name,
+            self.multi_company_record.id), timeout=15)
+
+        path = url_parse(response.url).path
+        self.assertEqual(path, '/web/login')
+
+        self.authenticate('admin', 'admin')
+
+        # Test Case 1
+        # Logged into company 1, try accessing record in company A
+        # _redirect_to_record should add company A in allowed_company_ids
+        response = self.url_open('/mail/view?model=%s&res_id=%s' % (
+            self.multi_company_record._name,
+            self.multi_company_record.id), timeout=15)
+
+        self.assertEqual(response.status_code, 200)
+
+        fragment = url_parse(response.url).fragment
+        cids = url_decode(fragment)['cids']
+
+        self.assertEqual(cids, '1,%s' % (self.company_A.id))
+
+        # Test Case 2
+        # Logged into company 1, try accessing record in company B
+        # _redirect_to_record should redirect to messaging as the user
+        # doesn't have any access for this company
+        self.multi_company_record.company_id = self.company_B
+
+        response = self.url_open('/mail/view?model=%s&res_id=%s' % (
+            self.multi_company_record._name,
+            self.multi_company_record.id), timeout=15)
+
+        self.assertEqual(response.status_code, 200)
+
+        fragment = url_parse(response.url).fragment
+        action = url_decode(fragment)['action']
+
+        self.assertEqual(action, 'mail.action_discuss')
diff --git a/addons/test_mail/tests/test_mail_tools.py b/addons/test_mail/tests/test_mail_tools.py
new file mode 100644
index 00000000..b36a1335
--- /dev/null
+++ b/addons/test_mail/tests/test_mail_tools.py
@@ -0,0 +1,83 @@
+# -*- coding: utf-8 -*-
+# Part of Odoo. See LICENSE file for full copyright and licensing details.
+
+from odoo.addons.test_mail.tests.common import TestMailCommon, TestRecipients
+from odoo.tests import tagged, users
+
+
+@tagged('mail_tools')
+class TestMailTools(TestMailCommon, TestRecipients):
+
+    @classmethod
+    def setUpClass(cls):
+        super(TestMailTools, cls).setUpClass()
+
+        cls._test_email = 'alfredoastaire@test.example.com'
+        cls.test_partner = cls.env['res.partner'].create({
+            'country_id': cls.env.ref('base.be').id,
+            'email': cls._test_email,
+            'mobile': '0456001122',
+            'name': 'Alfred Astaire',
+            'phone': '0456334455',
+        })
+
+    @users('employee')
+    def test_find_partner_from_emails(self):
+        Partner = self.env['res.partner']
+        test_partner = Partner.browse(self.test_partner.ids)
+        self.assertEqual(test_partner.email, self._test_email)
+
+        # test direct match
+        found = Partner._mail_find_partner_from_emails([self._test_email])
+        self.assertEqual(found, [test_partner])
+
+        # test encapsulated email
+        found = Partner._mail_find_partner_from_emails(['"Norbert Poiluchette" <%s>' % self._test_email])
+        self.assertEqual(found, [test_partner])
+
+        # test with wildcard "_"
+        found = Partner._mail_find_partner_from_emails(['alfred_astaire@test.example.com'])
+        self.assertEqual(found, [self.env['res.partner']])
+
+        # sub-check: this search does not consider _ as a wildcard
+        found = Partner._mail_search_on_partner(['alfred_astaire@test.example.com'])
+        self.assertEqual(found, self.env['res.partner'])
+
+        # test partners with encapsulated emails
+        # ------------------------------------------------------------
+        test_partner.sudo().write({'email': '"Alfred Mighty Power Astaire" <%s>' % self._test_email})
+
+        # test direct match
+        found = Partner._mail_find_partner_from_emails([self._test_email])
+        self.assertEqual(found, [test_partner])
+
+        # test encapsulated email
+        found = Partner._mail_find_partner_from_emails(['"Norbert Poiluchette" <%s>' % self._test_email])
+        self.assertEqual(found, [test_partner])
+
+        # test with wildcard "_"
+        found = Partner._mail_find_partner_from_emails(['alfred_astaire@test.example.com'])
+        self.assertEqual(found, [self.env['res.partner']])
+
+        # sub-check: this search does not consider _ as a wildcard
+        found = Partner._mail_search_on_partner(['alfred_astaire@test.example.com'])
+        self.assertEqual(found, self.env['res.partner'])
+
+        # test partners with look-alike emails
+        # ------------------------------------------------------------
+        for email_lookalike in [
+                'alfred.astaire@test.example.com',
+                'alfredoastaire@example.com',
+                'aalfredoastaire@test.example.com',
+                'alfredoastaire@test.example.comm']:
+            test_partner.sudo().write({'email': '"Alfred Astaire" <%s>' % email_lookalike})
+
+            # test direct match
+            found = Partner._mail_find_partner_from_emails([self._test_email])
+            self.assertEqual(found, [self.env['res.partner']])
+            # test encapsulated email
+            found = Partner._mail_find_partner_from_emails(['"Norbert Poiluchette" <%s>' % self._test_email])
+            self.assertEqual(found, [self.env['res.partner']])
+            # test with wildcard "_"
+            found = Partner._mail_find_partner_from_emails(['alfred_astaire@test.example.com'])
+            self.assertEqual(found, [self.env['res.partner']])
diff --git a/addons/test_mail/tests/test_message_management.py b/addons/test_mail/tests/test_message_management.py
new file mode 100644
index 00000000..289b3681
--- /dev/null
+++ b/addons/test_mail/tests/test_message_management.py
@@ -0,0 +1,120 @@
+# -*- coding: utf-8 -*-
+# Part of Odoo. See LICENSE file for full copyright and licensing details.
+
+from odoo.addons.mail.tests.common import mail_new_test_user
+from odoo.addons.test_mail.tests.common import TestMailCommon
+from odoo.tests import tagged
+from odoo.tools import mute_logger
+
+
+@tagged('mail_wizards')
+class TestMailResend(TestMailCommon):
+
+    @classmethod
+    def setUpClass(cls):
+        super(TestMailResend, cls).setUpClass()
+        cls.test_record = cls.env['mail.test.simple'].with_context(cls._test_context).create({'name': 'Test', 'email_from': 'ignasse@example.com'})
+
+        #Two users
+        cls.user1 = mail_new_test_user(cls.env, login='e1', groups='base.group_public', name='Employee 1', notification_type='email', email='e1')  # invalid email
+        cls.user2 = mail_new_test_user(cls.env, login='e2', groups='base.group_portal', name='Employee 2', notification_type='email', email='e2@example.com')
+        #Two partner
+        cls.partner1 = cls.env['res.partner'].with_context(cls._test_context).create({
+            'name': 'Partner 1',
+            'email': 'p1'  # invalid email
+        })
+        cls.partner2 = cls.env['res.partner'].with_context(cls._test_context).create({
+            'name': 'Partner 2',
+            'email': 'p2@example.com'
+        })
+        cls.partners = cls.env['res.partner'].concat(cls.user1.partner_id, cls.user2.partner_id, cls.partner1, cls.partner2)
+        cls.invalid_email_partners = cls.env['res.partner'].concat(cls.user1.partner_id, cls.partner1)
+
+    # @mute_logger('odoo.addons.mail.models.mail_mail')
+    def test_mail_resend_workflow(self):
+        with self.assertSinglePostNotifications(
+                [{'partner': partner, 'type': 'email', 'status': 'exception'} for partner in self.partners],
+                message_info={'message_type': 'notification'},
+                sim_error='connect_failure'):
+            message = self.test_record.with_user(self.user_admin).message_post(partner_ids=self.partners.ids, subtype_xmlid='mail.mt_comment', message_type='notification')
+
+        wizard = self.env['mail.resend.message'].with_context({'mail_message_to_resend': message.id}).create({})
+        self.assertEqual(wizard.notification_ids.mapped('res_partner_id'), self.partners, "wizard should manage notifications for each failed partner")
+
+        # three more failure sent on bus, one for each mail in failure and one for resend
+        self._reset_bus()
+        with self.mock_mail_gateway(), self.assertBus([(self.cr.dbname, 'res.partner', self.partner_admin.id)] * 3):
+            wizard.resend_mail_action()
+        done_msgs, done_notifs = self.assertMailNotifications(message, [
+            {'content': '', 'message_type': 'notification',
+             'notif': [{'partner': partner, 'type': 'email', 'status': 'exception' if partner in self.user1.partner_id | self.partner1 else 'sent'} for partner in self.partners]}]
+        )
+        self.assertEqual(wizard.notification_ids, done_notifs)
+        self.assertEqual(done_msgs, message)
+
+        self.user1.write({"email": 'u1@example.com'})
+
+        # two more failure update sent on bus, one for failed mail and one for resend
+        self._reset_bus()
+        with self.mock_mail_gateway(), self.assertBus([(self.cr.dbname, 'res.partner', self.partner_admin.id)] * 2):
+            self.env['mail.resend.message'].with_context({'mail_message_to_resend': message.id}).create({}).resend_mail_action()
+        done_msgs, done_notifs = self.assertMailNotifications(message, [
+            {'content': '', 'message_type': 'notification',
+             'notif': [{'partner': partner, 'type': 'email', 'status': 'exception' if partner == self.partner1 else 'sent', 'check_send': partner == self.partner1} for partner in self.partners]}]
+        )
+        self.assertEqual(wizard.notification_ids, done_notifs)
+        self.assertEqual(done_msgs, message)
+
+        self.partner1.write({"email": 'p1@example.com'})
+
+        # A success update should be sent on bus once the email has no more failure
+        self._reset_bus()
+        with self.mock_mail_gateway(), self.assertBus([(self.cr.dbname, 'res.partner', self.partner_admin.id)]):
+            self.env['mail.resend.message'].with_context({'mail_message_to_resend': message.id}).create({}).resend_mail_action()
+        self.assertMailNotifications(message, [
+            {'content': '', 'message_type': 'notification',
+             'notif': [{'partner': partner, 'type': 'email', 'status': 'sent', 'check_send': partner == self.partner1} for partner in self.partners]}]
+        )
+
+    @mute_logger('odoo.addons.mail.models.mail_mail')
+    def test_remove_mail_become_canceled(self):
+        # two failure sent on bus, one for each mail
+        self._reset_bus()
+        with self.mock_mail_gateway(), self.assertBus([(self.cr.dbname, 'res.partner', self.partner_admin.id)] * 2):
+            message = self.test_record.with_user(self.user_admin).message_post(partner_ids=self.partners.ids, subtype_xmlid='mail.mt_comment', message_type='notification')
+
+        self.assertMailNotifications(message, [
+            {'content': '', 'message_type': 'notification',
+             'notif': [{'partner': partner, 'type': 'email', 'status': 'exception' if partner in self.user1.partner_id | self.partner1 else 'sent'} for partner in self.partners]}]
+        )
+
+        wizard = self.env['mail.resend.message'].with_context({'mail_message_to_resend': message.id}).create({})
+        partners = wizard.partner_ids.mapped("partner_id")
+        self.assertEqual(self.invalid_email_partners, partners)
+        wizard.partner_ids.filtered(lambda p: p.partner_id == self.partner1).write({"resend": False})
+        wizard.resend_mail_action()
+
+        self.assertMailNotifications(message, [
+            {'content': '', 'message_type': 'notification',
+             'notif': [{'partner': partner, 'type': 'email',
+                        'status': (partner == self.user1.partner_id and 'exception') or (partner == self.partner1 and 'canceled') or 'sent'} for partner in self.partners]}]
+        )
+
+    @mute_logger('odoo.addons.mail.models.mail_mail')
+    def test_cancel_all(self):
+        self._reset_bus()
+        with self.mock_mail_gateway(), self.assertBus([(self.cr.dbname, 'res.partner', self.partner_admin.id)] * 2):
+            message = self.test_record.with_user(self.user_admin).message_post(partner_ids=self.partners.ids, subtype_xmlid='mail.mt_comment', message_type='notification')
+
+        wizard = self.env['mail.resend.message'].with_context({'mail_message_to_resend': message.id}).create({})
+        # one update for cancell
+        self._reset_bus()
+        with self.mock_mail_gateway(), self.assertBus([(self.cr.dbname, 'res.partner', self.partner_admin.id)] * 1):
+            wizard.cancel_mail_action()
+
+        self.assertMailNotifications(message, [
+            {'content': '', 'message_type': 'notification',
+             'notif': [{'partner': partner, 'type': 'email',
+                        'check_send': partner in self.user1.partner_id | self.partner1,
+                        'status': 'canceled' if partner in self.user1.partner_id | self.partner1 else 'sent'} for partner in self.partners]}]
+        )
diff --git a/addons/test_mail/tests/test_message_post.py b/addons/test_mail/tests/test_message_post.py
new file mode 100644
index 00000000..edf052d7
--- /dev/null
+++ b/addons/test_mail/tests/test_message_post.py
@@ -0,0 +1,397 @@
+# -*- coding: utf-8 -*-
+# Part of Odoo. See LICENSE file for full copyright and licensing details.
+
+import base64
+
+from unittest.mock import patch
+
+from odoo.addons.test_mail.data.test_mail_data import MAIL_TEMPLATE_PLAINTEXT
+from odoo.addons.test_mail.models.test_mail_models import MailTestSimple
+from odoo.addons.test_mail.tests.common import TestMailCommon, TestRecipients
+from odoo.api import call_kw
+from odoo.exceptions import AccessError
+from odoo.tests import tagged
+from odoo.tools import mute_logger, formataddr
+from odoo.tests.common import users
+
+
+@tagged('mail_post')
+class TestMessagePost(TestMailCommon, TestRecipients):
+
+    @classmethod
+    def setUpClass(cls):
+        super(TestMessagePost, cls).setUpClass()
+        cls._create_portal_user()
+        cls.test_record = cls.env['mail.test.simple'].with_context(cls._test_context).create({'name': 'Test', 'email_from': 'ignasse@example.com'})
+        cls._reset_mail_context(cls.test_record)
+        cls.user_admin.write({'notification_type': 'email'})
+
+    # This method should be run inside a post_install class to ensure that all
+    # message_post overrides are tested.
+    def test_message_post_return(self):
+        test_channel = self.env['mail.channel'].create({
+            'name': 'Test',
+        })
+        # Use call_kw as shortcut to simulate a RPC call.
+        messageId = call_kw(self.env['mail.channel'], 'message_post', [test_channel.id], {'body': 'test'})
+        self.assertTrue(isinstance(messageId, int))
+
+    @users('employee')
+    def test_notify_prepare_template_context_company_value(self):
+        """ Verify that the template context company value is right
+        after switching the env company or if a company_id is set
+        on mail record.
+        """
+        current_user = self.env.user
+        main_company = current_user.company_id
+        other_company = self.env['res.company'].with_user(self.user_admin).create({'name': 'Company B'})
+        current_user.sudo().write({'company_ids': [(4, other_company.id)]})
+        test_record = self.env['mail.test.multi.company'].with_user(self.user_admin).create({
+            'name': 'Multi Company Record',
+            'company_id': False,
+        })
+
+        # self.env.company.id = Main Company    AND    test_record.company_id = False
+        self.assertEqual(self.env.company.id, main_company.id)
+        self.assertEqual(test_record.company_id.id, False)
+        template_values = test_record._notify_prepare_template_context(test_record.message_ids, {})
+        self.assertEqual(template_values.get('company').id, self.env.company.id)
+
+        # self.env.company.id = Other Company    AND    test_record.company_id = False
+        current_user.company_id = other_company
+        test_record = self.env['mail.test.multi.company'].browse(test_record.id)
+        self.assertEqual(self.env.company.id, other_company.id)
+        self.assertEqual(test_record.company_id.id, False)
+        template_values = test_record._notify_prepare_template_context(test_record.message_ids, {})
+        self.assertEqual(template_values.get('company').id, self.env.company.id)
+
+        # self.env.company.id = Other Company    AND    test_record.company_id = Main Company
+        test_record.company_id = main_company
+        test_record = self.env['mail.test.multi.company'].browse(test_record.id)
+        self.assertEqual(self.env.company.id, other_company.id)
+        self.assertEqual(test_record.company_id.id, main_company.id)
+        template_values = test_record._notify_prepare_template_context(test_record.message_ids, {})
+        self.assertEqual(template_values.get('company').id, main_company.id)
+
+    def test_notify_recipients_internals(self):
+        pdata = self._generate_notify_recipients(self.partner_1 | self.partner_employee)
+        msg_vals = {
+            'body': 'Message body',
+            'model': self.test_record._name,
+            'res_id': self.test_record.id,
+            'subject': 'Message subject',
+        }
+        link_vals = {
+            'token': 'token_val',
+            'access_token': 'access_token_val',
+            'auth_signup_token': 'auth_signup_token_val',
+            'auth_login': 'auth_login_val',
+        }
+        notify_msg_vals = dict(msg_vals, **link_vals)
+        classify_res = self.env[self.test_record._name]._notify_classify_recipients(pdata, 'My Custom Model Name', msg_vals=notify_msg_vals)
+        # find back information for each recipients
+        partner_info = next(item for item in classify_res if item['recipients'] == self.partner_1.ids)
+        emp_info = next(item for item in classify_res if item['recipients'] == self.partner_employee.ids)
+
+        # partner: no access button
+        self.assertFalse(partner_info['has_button_access'])
+
+        # employee: access button and link
+        self.assertTrue(emp_info['has_button_access'])
+        for param, value in link_vals.items():
+            self.assertIn('%s=%s' % (param, value), emp_info['button_access']['url'])
+        self.assertIn('model=%s' % self.test_record._name, emp_info['button_access']['url'])
+        self.assertIn('res_id=%s' % self.test_record.id, emp_info['button_access']['url'])
+        self.assertNotIn('body', emp_info['button_access']['url'])
+        self.assertNotIn('subject', emp_info['button_access']['url'])
+
+    @mute_logger('odoo.addons.mail.models.mail_mail')
+    def test_post_needaction(self):
+        (self.user_employee | self.user_admin).write({'notification_type': 'inbox'})
+        with self.assertSinglePostNotifications([{'partner': self.partner_employee, 'type': 'inbox'}], {'content': 'Body'}):
+            self.test_record.message_post(
+                body='Body', message_type='comment', subtype_xmlid='mail.mt_comment',
+                partner_ids=[self.user_employee.partner_id.id])
+
+        self.test_record.message_subscribe([self.partner_1.id])
+        with self.assertSinglePostNotifications([
+                {'partner': self.partner_employee, 'type': 'inbox'},
+                {'partner': self.partner_1, 'type': 'email'}], {'content': 'NewBody'}):
+            self.test_record.message_post(
+                body='NewBody', message_type='comment', subtype_xmlid='mail.mt_comment',
+                partner_ids=[self.user_employee.partner_id.id])
+
+        with self.assertSinglePostNotifications([
+                {'partner': self.partner_1, 'type': 'email'},
+                {'partner': self.partner_portal, 'type': 'email'}], {'content': 'ToPortal'}):
+            self.test_record.message_post(
+                body='ToPortal', message_type='comment', subtype_xmlid='mail.mt_comment',
+                partner_ids=[self.partner_portal.id])
+
+    def test_post_inactive_follower(self):
+        # In some case odoobot is follower of a record.
+        # Even if it shouldn't be the case, we want to be sure that odoobot is not notified
+        (self.user_employee | self.user_admin).write({'notification_type': 'inbox'})
+        self.test_record._message_subscribe(self.user_employee.partner_id.ids)
+        with self.assertSinglePostNotifications([{'partner': self.partner_employee, 'type': 'inbox'}], {'content': 'Test'}):
+            self.test_record.message_post(
+                body='Test', message_type='comment', subtype_xmlid='mail.mt_comment')
+
+        self.user_employee.active = False
+        # at this point, partner is still active and would receive an email notification
+        self.user_employee.partner_id._write({'active': False})
+        with self.assertPostNotifications([{'content': 'Test', 'notif': []}]):
+            self.test_record.message_post(
+                body='Test', message_type='comment', subtype_xmlid='mail.mt_comment')
+
+    @mute_logger('odoo.addons.mail.models.mail_mail')
+    def test_post_notifications(self):
+        _body, _subject = '<p>Test Body</p>', 'Test Subject'
+
+        # subscribe second employee to the group to test notifications
+        self.test_record.message_subscribe(partner_ids=[self.user_admin.partner_id.id])
+
+        with self.assertSinglePostNotifications(
+                [{'partner': self.partner_1, 'type': 'email'},
+                 {'partner': self.partner_2, 'type': 'email'},
+                 {'partner': self.partner_admin, 'type': 'email'}],
+                {'content': _body},
+                mail_unlink_sent=True):
+            msg = self.test_record.with_user(self.user_employee).message_post(
+                body=_body, subject=_subject,
+                message_type='comment', subtype_xmlid='mail.mt_comment',
+                partner_ids=[self.partner_1.id, self.partner_2.id]
+            )
+
+        # message content
+        self.assertEqual(msg.subject, _subject)
+        self.assertEqual(msg.body, _body)
+        self.assertEqual(msg.partner_ids, self.partner_1 | self.partner_2)
+        self.assertEqual(msg.notified_partner_ids, self.user_admin.partner_id | self.partner_1 | self.partner_2)
+        self.assertEqual(msg.channel_ids, self.env['mail.channel'])
+
+        # notifications emails should have been deleted
+        self.assertFalse(self.env['mail.mail'].sudo().search([('mail_message_id', '=', msg.id)]),
+                         'message_post: mail.mail notifications should have been auto-deleted')
+
+    @mute_logger('odoo.addons.mail.models.mail_mail')
+    def test_post_notifications_keep_emails(self):
+        self.test_record.message_subscribe(partner_ids=[self.user_admin.partner_id.id])
+
+        msg = self.test_record.with_user(self.user_employee).message_post(
+            body='Test', subject='Test',
+            message_type='comment', subtype_xmlid='mail.mt_comment',
+            partner_ids=[self.partner_1.id, self.partner_2.id],
+            mail_auto_delete=False
+        )
+
+        # notifications emails should not have been deleted: one for customers, one for user
+        self.assertEqual(len(self.env['mail.mail'].sudo().search([('mail_message_id', '=', msg.id)])), 2)
+
+    @mute_logger('odoo.addons.mail.models.mail_mail')
+    def test_post_notifications_emails_tweak(self):
+        pass
+        # we should check _notification_groups behavior, for emails and buttons
+
+    @mute_logger('odoo.addons.mail.models.mail_mail')
+    def test_post_attachments(self):
+        _attachments = [
+            ('List1', b'My first attachment'),
+            ('List2', b'My second attachment')
+        ]
+        _attach_1 = self.env['ir.attachment'].with_user(self.user_employee).create({
+            'name': 'Attach1',
+            'datas': 'bWlncmF0aW9uIHRlc3Q=',
+            'res_model': 'mail.compose.message', 'res_id': 0})
+        _attach_2 = self.env['ir.attachment'].with_user(self.user_employee).create({
+            'name': 'Attach2',
+            'datas': 'bWlncmF0aW9uIHRlc3Q=',
+            'res_model': 'mail.compose.message', 'res_id': 0})
+
+        with self.mock_mail_gateway():
+            msg = self.test_record.with_user(self.user_employee).message_post(
+                body='Test', subject='Test',
+                message_type='comment', subtype_xmlid='mail.mt_comment',
+                attachment_ids=[_attach_1.id, _attach_2.id],
+                partner_ids=[self.partner_1.id],
+                attachments=_attachments,
+            )
+
+        # message attachments
+        self.assertEqual(len(msg.attachment_ids), 4)
+        self.assertEqual(set(msg.attachment_ids.mapped('res_model')), set([self.test_record._name]))
+        self.assertEqual(set(msg.attachment_ids.mapped('res_id')), set([self.test_record.id]))
+        self.assertEqual(set([base64.b64decode(x) for x in msg.attachment_ids.mapped('datas')]),
+                         set([b'migration test', _attachments[0][1], _attachments[1][1]]))
+        self.assertTrue(set([_attach_1.id, _attach_2.id]).issubset(msg.attachment_ids.ids),
+                        'message_post: mail.message attachments duplicated')
+
+        # notification email attachments
+        self.assertSentEmail(self.user_employee.partner_id, [self.partner_1])
+        # self.assertEqual(len(self._mails), 1)
+        self.assertEqual(len(self._mails[0]['attachments']), 4)
+        self.assertIn(('List1', b'My first attachment', 'application/octet-stream'), self._mails[0]['attachments'])
+        self.assertIn(('List2', b'My second attachment', 'application/octet-stream'), self._mails[0]['attachments'])
+        self.assertIn(('Attach1', b'migration test', 'application/octet-stream'),  self._mails[0]['attachments'])
+        self.assertIn(('Attach2', b'migration test', 'application/octet-stream'), self._mails[0]['attachments'])
+
+    @mute_logger('odoo.addons.mail.models.mail_mail')
+    def test_post_answer(self):
+        with self.mock_mail_gateway():
+            parent_msg = self.test_record.with_user(self.user_employee).message_post(
+                body='<p>Test</p>', subject='Test Subject',
+                message_type='comment', subtype_xmlid='mail.mt_comment')
+
+        self.assertEqual(parent_msg.partner_ids, self.env['res.partner'])
+        self.assertNotSentEmail()
+
+        with self.assertPostNotifications([{'content': '<p>Test Answer</p>', 'notif': [{'partner': self.partner_1, 'type': 'email'}]}]):
+            msg = self.test_record.with_user(self.user_employee).message_post(
+                body='<p>Test Answer</p>',
+                message_type='comment', subtype_xmlid='mail.mt_comment',
+                partner_ids=[self.partner_1.id],
+                parent_id=parent_msg.id)
+
+        self.assertEqual(msg.parent_id.id, parent_msg.id)
+        self.assertEqual(msg.partner_ids, self.partner_1)
+        self.assertEqual(parent_msg.partner_ids, self.env['res.partner'])
+
+        # check notification emails: references
+        self.assertSentEmail(self.user_employee.partner_id, [self.partner_1], ref_content='openerp-%d-mail.test.simple' % self.test_record.id)
+        # self.assertTrue(all('openerp-%d-mail.test.simple' % self.test_record.id in m['references'] for m in self._mails))
+
+        new_msg = self.test_record.with_user(self.user_employee).message_post(
+            body='<p>Test Answer Bis</p>',
+            message_type='comment', subtype_xmlid='mail.mt_comment',
+            parent_id=msg.id)
+
+        self.assertEqual(new_msg.parent_id.id, parent_msg.id, 'message_post: flatten error')
+        self.assertEqual(new_msg.partner_ids, self.env['res.partner'])
+
+    @mute_logger('odoo.addons.mail.models.mail_mail')
+    def test_post_portal_ok(self):
+        self.test_record.message_subscribe((self.partner_1 | self.user_employee.partner_id).ids)
+
+        with self.assertPostNotifications([{'content': '<p>Test</p>', 'notif': [
+            {'partner': self.partner_employee, 'type': 'inbox'},
+            {'partner': self.partner_1, 'type': 'email'}]}
+        ]), patch.object(MailTestSimple, 'check_access_rights', return_value=True):
+            new_msg = self.test_record.with_user(self.user_portal).message_post(
+                body='<p>Test</p>', subject='Subject',
+                message_type='comment', subtype_xmlid='mail.mt_comment')
+
+        self.assertEqual(new_msg.sudo().notified_partner_ids, (self.partner_1 | self.user_employee.partner_id))
+
+    def test_post_portal_crash(self):
+        with self.assertRaises(AccessError):
+            self.test_record.with_user(self.user_portal).message_post(
+                body='<p>Test</p>', subject='Subject',
+                message_type='comment', subtype_xmlid='mail.mt_comment')
+
+    @mute_logger('odoo.addons.mail.models.mail_mail', 'odoo.addons.mail.models.mail_thread')
+    def test_post_internal(self):
+        self.test_record.message_subscribe([self.user_admin.partner_id.id])
+        msg = self.test_record.with_user(self.user_employee).message_post(
+            body='My Body', subject='My Subject',
+            message_type='comment', subtype_xmlid='mail.mt_note')
+        self.assertEqual(msg.partner_ids, self.env['res.partner'])
+        self.assertEqual(msg.notified_partner_ids, self.env['res.partner'])
+
+        self.format_and_process(
+            MAIL_TEMPLATE_PLAINTEXT, self.user_admin.email, 'not_my_businesss@example.com',
+            msg_id='<1198923581.41972151344608186800.JavaMail.diff1@agrolait.com>',
+            extra='In-Reply-To:\r\n\t%s\n' % msg.message_id,
+            target_model='mail.test.simple')
+        reply = self.test_record.message_ids - msg
+        self.assertTrue(reply)
+        self.assertEqual(reply.subtype_id, self.env.ref('mail.mt_note'))
+        self.assertEqual(reply.notified_partner_ids, self.user_employee.partner_id)
+        self.assertEqual(reply.parent_id, msg)
+
+    def test_post_log(self):
+        new_note = self.test_record.with_user(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.notified_partner_ids, self.env['res.partner'])
+
+    @mute_logger('odoo.addons.mail.models.mail_mail')
+    def test_post_notify(self):
+        self.user_employee.write({'notification_type': 'inbox'})
+
+        with self.mock_mail_gateway():
+            new_notification = self.test_record.message_notify(
+                subject='This should be a subject',
+                body='<p>You have received a notification</p>',
+                partner_ids=[self.partner_1.id, self.partner_admin.id, self.user_employee.partner_id.id],
+            )
+
+        self.assertEqual(new_notification.subtype_id, self.env.ref('mail.mt_note'))
+        self.assertEqual(new_notification.message_type, 'user_notification')
+        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.notified_partner_ids, self.partner_1 | self.user_employee.partner_id | self.partner_admin)
+        self.assertNotIn(new_notification, self.test_record.message_ids)
+
+        admin_mails = [x for x in self._mails if self.partner_admin.name in x.get('email_to')[0]]
+        self.assertEqual(len(admin_mails), 1, 'There should be exactly one email sent to admin')
+        admin_mail = admin_mails[0].get('body')
+        admin_access_link = admin_mail[admin_mail.index('model='):admin_mail.index('/>') - 1] if 'model=' in admin_mail else None
+  
+        self.assertIsNotNone(admin_access_link, 'The email sent to admin should contain an access link')
+        self.assertIn('model=%s' % self.test_record._name, admin_access_link, 'The access link should contain a valid model argument')
+        self.assertIn('res_id=%d' % self.test_record.id, admin_access_link, 'The access link should contain a valid res_id argument')
+
+        partner_mails = [x for x in self._mails if self.partner_1.name in x.get('email_to')[0]]
+        self.assertEqual(len(partner_mails), 1, 'There should be exactly one email sent to partner')
+        partner_mail = partner_mails[0].get('body')
+        self.assertNotIn('/mail/view?model=', partner_mail, 'The email sent to admin should not contain an access link')
+        # todo xdo add test message_notify on thread with followers and stuff
+
+    @mute_logger('odoo.addons.mail.models.mail_mail')
+    def test_post_post_w_template(self):
+        test_record = self.env['mail.test.simple'].with_context(self._test_context).create({'name': 'Test', 'email_from': 'ignasse@example.com'})
+        self.user_employee.write({
+            'groups_id': [(4, self.env.ref('base.group_partner_manager').id)],
+        })
+        _attachments = [{
+            'name': 'first.txt',
+            'datas': base64.b64encode(b'My first attachment'),
+            'res_model': 'res.partner',
+            'res_id': self.user_admin.partner_id.id
+        }, {
+            'name': 'second.txt',
+            'datas': base64.b64encode(b'My second attachment'),
+            'res_model': 'res.partner',
+            'res_id': self.user_admin.partner_id.id
+        }]
+        email_1 = 'test1@example.com'
+        email_2 = 'test2@example.com'
+        email_3 = self.partner_1.email
+        self._create_template('mail.test.simple', {
+            'attachment_ids': [(0, 0, _attachments[0]), (0, 0, _attachments[1])],
+            'partner_to': '%s,%s' % (self.partner_2.id, self.user_admin.partner_id.id),
+            'email_to': '%s, %s' % (email_1, email_2),
+            'email_cc': '%s' % email_3,
+        })
+        # admin should receive emails
+        self.user_admin.write({'notification_type': 'email'})
+        # Force the attachments of the template to be in the natural order.
+        self.email_template.invalidate_cache(['attachment_ids'], ids=self.email_template.ids)
+
+        with self.mock_mail_gateway():
+            test_record.with_user(self.user_employee).message_post_with_template(self.email_template.id, composition_mode='comment')
+
+        new_partners = self.env['res.partner'].search([('email', 'in', [email_1, email_2])])
+        for r in [self.partner_1, self.partner_2, new_partners[0], new_partners[1], self.partner_admin]:
+            self.assertSentEmail(
+                self.user_employee.partner_id,
+                [r],
+                subject='About %s' % test_record.name,
+                body_content=test_record.name,
+                attachments=[('first.txt', b'My first attachment', 'text/plain'), ('second.txt', b'My second attachment', 'text/plain')])
diff --git a/addons/test_mail/tests/test_message_track.py b/addons/test_mail/tests/test_message_track.py
new file mode 100644
index 00000000..df024c1e
--- /dev/null
+++ b/addons/test_mail/tests/test_message_track.py
@@ -0,0 +1,353 @@
+# -*- coding: utf-8 -*-
+# Part of Odoo. See LICENSE file for full copyright and licensing details.
+
+from unittest.mock import patch
+
+from odoo.addons.test_mail.tests.common import TestMailCommon
+from odoo.tests.common import tagged
+from odoo.tests import Form
+
+
+@tagged('mail_track')
+class TestTracking(TestMailCommon):
+
+    def setUp(self):
+        super(TestTracking, self).setUp()
+
+        record = self.env['mail.test.ticket'].with_user(self.user_employee).with_context(self._test_context).create({
+            'name': 'Test',
+        })
+        self.flush_tracking()
+        self.record = record.with_context(mail_notrack=False)
+
+    def test_message_track_no_tracking(self):
+        """ Update a set of non tracked fields -> no message, no tracking """
+        self.record.write({
+            'name': 'Tracking or not',
+            'count': 32,
+        })
+        self.flush_tracking()
+        self.assertEqual(self.record.message_ids, self.env['mail.message'])
+
+    def test_message_track_no_subtype(self):
+        """ Update some tracked fields not linked to some subtype -> message with onchange """
+        customer = self.env['res.partner'].create({'name': 'Customer', 'email': 'cust@example.com'})
+        with self.mock_mail_gateway():
+            self.record.write({
+                'name': 'Test2',
+                'customer_id': customer.id,
+            })
+            self.flush_tracking()
+
+        # one new message containing tracking; without subtype linked to tracking, a note is generated
+        self.assertEqual(len(self.record.message_ids), 1)
+        self.assertEqual(self.record.message_ids.subtype_id, self.env.ref('mail.mt_note'))
+
+        # no specific recipients except those following notes, no email
+        self.assertEqual(self.record.message_ids.partner_ids, self.env['res.partner'])
+        self.assertEqual(self.record.message_ids.notified_partner_ids, self.env['res.partner'])
+        self.assertNotSentEmail()
+
+        # verify tracked value
+        self.assertTracking(
+            self.record.message_ids,
+            [('customer_id', 'many2one', False, customer)  # onchange tracked field
+             ])
+
+    def test_message_track_subtype(self):
+        """ Update some tracked fields linked to some subtype -> message with onchange """
+        self.record.message_subscribe(
+            partner_ids=[self.user_admin.partner_id.id],
+            subtype_ids=[self.env.ref('test_mail.st_mail_test_ticket_container_upd').id]
+        )
+
+        container = self.env['mail.test.container'].with_context(mail_create_nosubscribe=True).create({'name': 'Container'})
+        self.record.write({
+            'name': 'Test2',
+            'email_from': 'noone@example.com',
+            'container_id': container.id,
+        })
+        self.flush_tracking()
+        # one new message containing tracking; subtype linked to tracking
+        self.assertEqual(len(self.record.message_ids), 1)
+        self.assertEqual(self.record.message_ids.subtype_id, self.env.ref('test_mail.st_mail_test_ticket_container_upd'))
+
+        # no specific recipients except those following container
+        self.assertEqual(self.record.message_ids.partner_ids, self.env['res.partner'])
+        self.assertEqual(self.record.message_ids.notified_partner_ids, self.user_admin.partner_id)
+
+        # verify tracked value
+        self.assertTracking(
+            self.record.message_ids,
+            [('container_id', 'many2one', False, container)  # onchange tracked field
+             ])
+
+    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_ticket_tracking_tpl').id})
+        self.assertEqual(self.record.message_ids, self.env['mail.message'])
+
+        with self.mock_mail_gateway():
+            self.record.write({
+                'name': 'Test2',
+                'customer_id': self.user_admin.partner_id.id,
+            })
+            self.flush_tracking()
+
+        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.assertSentEmail(self.record.env.user.partner_id, [self.partner_admin], 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 test_message_track_template_at_create(self):
+        """ Create a record with tracking template on create, template should be sent."""
+
+        Model = self.env['mail.test.ticket'].with_user(self.user_employee).with_context(self._test_context)
+        Model = Model.with_context(mail_notrack=False)
+        with self.mock_mail_gateway():
+            record = Model.create({
+                'name': 'Test',
+                'customer_id': self.user_admin.partner_id.id,
+                'mail_template': self.env.ref('test_mail.mail_test_ticket_tracking_tpl').id,
+            })
+            self.flush_tracking()
+
+        self.assertEqual(len(record.message_ids), 1, 'should have 1 new messages for template')
+        # one new message containing the template linked to tracking
+        self.assertEqual(record.message_ids[0].subject, 'Test Template')
+        self.assertEqual(record.message_ids[0].body, '<p>Hello Test</p>')
+        # one email send due to template
+        self.assertSentEmail(self.record.env.user.partner_id, [self.partner_admin], body='<p>Hello Test</p>')
+
+    def test_create_partner_from_tracking_multicompany(self):
+        company1 = self.env['res.company'].create({'name': 'company1'})
+        self.env.user.write({'company_ids': [(4, company1.id, False)]})
+        self.assertNotEqual(self.env.company, company1)
+
+        email_new_partner = "diamonds@rust.com"
+        Partner = self.env['res.partner']
+        self.assertFalse(Partner.search([('email', '=', email_new_partner)]))
+
+        template = self.env['mail.template'].create({
+            'model_id': self.env['ir.model']._get('mail.test.track').id,
+            'name': 'AutoTemplate',
+            'subject': 'autoresponse',
+            'email_from': self.env.user.email_formatted,
+            'email_to': "${object.email_from}",
+            'body_html': "<div>A nice body</div>",
+        })
+
+        def patched_message_track_post_template(*args, **kwargs):
+            if args[0]._name == "mail.test.track":
+                args[0].message_post_with_template(template.id)
+            return True
+
+        with patch('odoo.addons.mail.models.mail_thread.MailThread._message_track_post_template', patched_message_track_post_template):
+            self.env['mail.test.track'].create({
+                'email_from': email_new_partner,
+                'company_id': company1.id,
+                'user_id': self.env.user.id, # trigger track template
+            })
+            self.flush_tracking()
+
+        new_partner = Partner.search([('email', '=', email_new_partner)])
+        self.assertTrue(new_partner)
+        self.assertEqual(new_partner.company_id, company1)
+
+    def test_track_template(self):
+        # Test: Check that default_* keys are not taken into account in _message_track_post_template
+        magic_code = 'Up-Up-Down-Down-Left-Right-Left-Right-Square-Triangle'
+
+        mt_name_changed = self.env['mail.message.subtype'].create({
+            'name': 'MAGIC CODE WOOP WOOP',
+            'description': 'SPECIAL CONTENT UNLOCKED'
+        })
+        self.env['ir.model.data'].create({
+            'name': 'mt_name_changed',
+            'model': 'mail.message.subtype',
+            'module': 'mail',
+            'res_id': mt_name_changed.id
+        })
+        mail_template = self.env['mail.template'].create({
+            'name': 'SPECIAL CONTENT UNLOCKED',
+            'subject': 'SPECIAL CONTENT UNLOCKED',
+            'model_id': self.env.ref('test_mail.model_mail_test_container').id,
+            'auto_delete': True,
+            'body_html': '''<div>WOOP WOOP</div>''',
+        })
+
+        def _track_subtype(self, init_values):
+            if 'name' in init_values and init_values['name'] == magic_code:
+                return 'mail.mt_name_changed'
+            return False
+        self.registry('mail.test.container')._patch_method('_track_subtype', _track_subtype)
+
+        def _track_template(self, changes):
+            res = {}
+            if 'name' in changes:
+                res['name'] = (mail_template, {'composition_mode': 'mass_mail'})
+            return res
+        self.registry('mail.test.container')._patch_method('_track_template', _track_template)
+
+        cls = type(self.env['mail.test.container'])
+        self.assertFalse(hasattr(getattr(cls, 'name'), 'track_visibility'))
+        getattr(cls, 'name').track_visibility = 'always'
+
+        @self.addCleanup
+        def cleanup():
+            del getattr(cls, 'name').track_visibility
+
+        test_mail_record = self.env['mail.test.container'].create({
+            'name': 'Zizizatestmailname',
+            'description': 'Zizizatestmaildescription',
+        })
+        test_mail_record.with_context(default_parent_id=2147483647).write({'name': magic_code})
+
+    def test_message_track_multiple(self):
+        """ check that multiple updates generate a single tracking message """
+        container = self.env['mail.test.container'].with_context(mail_create_nosubscribe=True).create({'name': 'Container'})
+        self.record.name = 'Zboub'
+        self.record.customer_id = self.user_admin.partner_id
+        self.record.user_id = self.user_admin
+        self.record.container_id = container
+        self.flush_tracking()
+
+        # should have a single message with all tracked fields
+        self.assertEqual(len(self.record.message_ids), 1, 'should have 1 tracking message')
+        self.assertTracking(self.record.message_ids[0], [
+            ('customer_id', 'many2one', False, self.user_admin.partner_id),
+            ('user_id', 'many2one', False, self.user_admin),
+            ('container_id', 'many2one', False, container),
+        ])
+
+    def test_tracked_compute(self):
+        # no tracking at creation
+        record = self.env['mail.test.track.compute'].create({})
+        self.flush_tracking()
+        self.assertEqual(len(record.message_ids), 1)
+        self.assertEqual(len(record.message_ids[0].tracking_value_ids), 0)
+
+        # assign partner_id: one tracking message for the modified field and all
+        # the stored and non-stored computed fields on the record
+        partner = self.env['res.partner'].create({
+            'name': 'Foo',
+            'email': 'foo@example.com',
+            'phone': '1234567890',
+        })
+        record.partner_id = partner
+        self.flush_tracking()
+        self.assertEqual(len(record.message_ids), 2)
+        self.assertEqual(len(record.message_ids[0].tracking_value_ids), 4)
+        self.assertTracking(record.message_ids[0], [
+            ('partner_id', 'many2one', False, partner),
+            ('partner_name', 'char', False, 'Foo'),
+            ('partner_email', 'char', False, 'foo@example.com'),
+            ('partner_phone', 'char', False, '1234567890'),
+        ])
+
+        # modify partner: one tracking message for the only recomputed field
+        partner.write({'name': 'Fool'})
+        self.flush_tracking()
+        self.assertEqual(len(record.message_ids), 3)
+        self.assertEqual(len(record.message_ids[0].tracking_value_ids), 1)
+        self.assertTracking(record.message_ids[0], [
+            ('partner_name', 'char', 'Foo', 'Fool'),
+        ])
+
+        # modify partner: one tracking message for both stored computed fields;
+        # the non-stored computed fields have no tracking
+        partner.write({
+            'name': 'Bar',
+            'email': 'bar@example.com',
+            'phone': '0987654321',
+        })
+        # force recomputation of 'partner_phone' to make sure it does not
+        # generate tracking values
+        self.assertEqual(record.partner_phone, '0987654321')
+        self.flush_tracking()
+        self.assertEqual(len(record.message_ids), 4)
+        self.assertEqual(len(record.message_ids[0].tracking_value_ids), 2)
+        self.assertTracking(record.message_ids[0], [
+            ('partner_name', 'char', 'Fool', 'Bar'),
+            ('partner_email', 'char', 'foo@example.com', 'bar@example.com'),
+        ])
+
+
+@tagged('mail_track')
+class TestTrackingInternals(TestMailCommon):
+
+    def setUp(self):
+        super(TestTrackingInternals, self).setUp()
+
+        record = self.env['mail.test.ticket'].with_user(self.user_employee).with_context(self._test_context).create({
+            'name': 'Test',
+        })
+        self.flush_tracking()
+        self.record = record.with_context(mail_notrack=False)
+
+    def test_track_groups(self):
+        field = self.record._fields['email_from']
+        self.addCleanup(setattr, field, 'groups', field.groups)
+        field.groups = 'base.group_erp_manager'
+
+        self.record.sudo().write({'email_from': 'X'})
+        self.flush_tracking()
+
+        msg_emp = self.record.message_ids.message_format()
+        msg_sudo = self.record.sudo().message_ids.message_format()
+        self.assertFalse(msg_emp[0].get('tracking_value_ids'), "should not have protected tracking values")
+        self.assertTrue(msg_sudo[0].get('tracking_value_ids'), "should have protected tracking values")
+
+        msg_emp = self.record._notify_prepare_template_context(self.record.message_ids, {})
+        msg_sudo = self.record.sudo()._notify_prepare_template_context(self.record.message_ids, {})
+        self.assertFalse(msg_emp.get('tracking_values'), "should not have protected tracking values")
+        self.assertTrue(msg_sudo.get('tracking_values'), "should have protected tracking values")
+
+        # test editing the record with user not in the group of the field
+        self.record.invalidate_cache()
+        self.record.clear_caches()
+        record_form = Form(self.record.with_user(self.user_employee))
+        record_form.name = 'TestDoNoCrash'
+        # the employee user must be able to save the fields on which he can write
+        # if we fetch all the tracked fields, ignoring the group of the current user
+        # it will crash and it shouldn't
+        record = record_form.save()
+        self.assertEqual(record.name, 'TestDoNoCrash')
+
+    def test_track_sequence(self):
+        """ Update some tracked fields and check that the mail.tracking.value are ordered according to their tracking_sequence"""
+        self.record.write({
+            'name': 'Zboub',
+            'customer_id': self.user_admin.partner_id.id,
+            'user_id': self.user_admin.id,
+            'container_id': self.env['mail.test.container'].with_context(mail_create_nosubscribe=True).create({'name': 'Container'}).id
+        })
+        self.flush_tracking()
+        self.assertEqual(len(self.record.message_ids), 1, 'should have 1 tracking message')
+
+        tracking_values = self.env['mail.tracking.value'].search([('mail_message_id', '=', self.record.message_ids.id)])
+        self.assertEqual(tracking_values[0].tracking_sequence, 1)
+        self.assertEqual(tracking_values[1].tracking_sequence, 2)
+        self.assertEqual(tracking_values[2].tracking_sequence, 100)
+
+    def test_unlinked_field(self):
+        record_sudo = self.record.sudo()
+        record_sudo.write({'email_from': 'new_value'})  # create a tracking value
+        self.flush_tracking()
+        self.assertEqual(len(record_sudo.message_ids.tracking_value_ids), 1)
+        ir_model_field = self.env['ir.model.fields'].search([
+            ('model', '=', 'mail.test.ticket'),
+            ('name', '=', 'email_from')])
+        ir_model_field.with_context(_force_unlink=True).unlink()
+        self.assertEqual(len(record_sudo.message_ids.tracking_value_ids), 0)
diff --git a/addons/test_mail/tests/test_performance.py b/addons/test_mail/tests/test_performance.py
new file mode 100644
index 00000000..6862160a
--- /dev/null
+++ b/addons/test_mail/tests/test_performance.py
@@ -0,0 +1,1021 @@
+# -*- coding: utf-8 -*-
+# Part of Odoo. See LICENSE file for full copyright and licensing details.
+import base64
+
+from odoo.addons.base.tests.common import TransactionCaseWithUserDemo
+from odoo.tests.common import users, warmup
+from odoo.tests import tagged
+from odoo.tools import mute_logger, formataddr
+
+
+@tagged('mail_performance')
+class BaseMailPerformance(TransactionCaseWithUserDemo):
+
+    def setUp(self):
+        super(BaseMailPerformance, self).setUp()
+        self._quick_create_ctx = {
+            'no_reset_password': True,
+            'mail_create_nolog': True,
+            'mail_create_nosubscribe': True,
+            'mail_notrack': True,
+        }
+        self.user_employee = self.env['res.users'].with_context(self._quick_create_ctx).create({
+            'name': 'Ernest Employee',
+            'login': 'emp',
+            'email': 'e.e@example.com',
+            'signature': '--\nErnest',
+            'notification_type': 'inbox',
+            'groups_id': [(6, 0, [self.env.ref('base.group_user').id, self.env.ref('base.group_partner_manager').id])],
+        })
+
+        # patch registry to simulate a ready environment
+        self.patch(self.env.registry, 'ready', True)
+
+
+@tagged('mail_performance')
+class TestMailPerformance(BaseMailPerformance):
+
+    def setUp(self):
+        super(TestMailPerformance, self).setUp()
+
+        self.res_partner_3 = self.env['res.partner'].create({
+            'name': 'Gemini Furniture',
+            'email': 'gemini.furniture39@example.com',
+        })
+        self.res_partner_4 = self.env['res.partner'].create({
+            'name': 'Ready Mat',
+            'email': 'ready.mat28@example.com',
+        })
+        self.res_partner_10 = self.env['res.partner'].create({
+            'name': 'The Jackson Group',
+            'email': 'jackson.group82@example.com',
+        })
+        self.res_partner_12 = self.env['res.partner'].create({
+            'name': 'Azure Interior',
+            'email': 'azure.Interior24@example.com',
+        })
+        self.env['mail.performance.thread'].create([
+            {
+                'name': 'Object 0',
+                'value': 0,
+                'partner_id': self.res_partner_3.id,
+            }, {
+                'name': 'Object 1',
+                'value': 10,
+                'partner_id': self.res_partner_3.id,
+            }, {
+                'name': 'Object 2',
+                'value': 20,
+                'partner_id': self.res_partner_4.id,
+            }, {
+                'name': 'Object 3',
+                'value': 30,
+                'partner_id': self.res_partner_10.id,
+            }, {
+                'name': 'Object 4',
+                'value': 40,
+                'partner_id': self.res_partner_12.id,
+            }
+        ])
+
+    @users('__system__', 'demo')
+    @warmup
+    def test_read_mail(self):
+        """ Read records inheriting from 'mail.thread'. """
+        records = self.env['mail.performance.thread'].search([])
+        self.assertEqual(len(records), 5)
+
+        with self.assertQueryCount(__system__=2, demo=2):
+            # without cache
+            for record in records:
+                record.partner_id.country_id.name
+
+        with self.assertQueryCount(0):
+            # with cache
+            for record in records:
+                record.partner_id.country_id.name
+
+        with self.assertQueryCount(0):
+            # value_pc must have been prefetched, too
+            for record in records:
+                record.value_pc
+
+    @users('__system__', 'demo')
+    @warmup
+    def test_write_mail(self):
+        """ Write records inheriting from 'mail.thread' (no recomputation). """
+        records = self.env['mail.performance.thread'].search([])
+        self.assertEqual(len(records), 5)
+
+        with self.assertQueryCount(__system__=2, demo=2):
+            records.write({'name': 'X'})
+
+    @users('__system__', 'demo')
+    @warmup
+    def test_write_mail_with_recomputation(self):
+        """ Write records inheriting from 'mail.thread' (with recomputation). """
+        records = self.env['mail.performance.thread'].search([])
+        self.assertEqual(len(records), 5)
+
+        with self.assertQueryCount(__system__=2, demo=2):
+            records.write({'value': 42})
+
+    @users('__system__', 'demo')
+    @warmup
+    def test_write_mail_with_tracking(self):
+        """ Write records inheriting from 'mail.thread' (with field tracking). """
+        record = self.env['mail.performance.thread'].create({
+            'name': 'Test',
+            'track': 'Y',
+            'value': 40,
+            'partner_id': self.res_partner_12.id,
+        })
+
+        with self.assertQueryCount(__system__=3, demo=3):
+            record.track = 'X'
+
+    @users('__system__', 'demo')
+    @warmup
+    def test_create_mail(self):
+        """ Create records inheriting from 'mail.thread' (without field tracking). """
+        model = self.env['mail.performance.thread']
+
+        with self.assertQueryCount(__system__=2, demo=2):
+            model.with_context(tracking_disable=True).create({'name': 'X'})
+
+    @users('__system__', 'demo')
+    @warmup
+    def test_create_mail_with_tracking(self):
+        """ Create records inheriting from 'mail.thread' (with field tracking). """
+        with self.assertQueryCount(__system__=7, demo=7):
+            self.env['mail.performance.thread'].create({'name': 'X'})
+
+    @users('__system__', 'emp')
+    @warmup
+    def test_create_mail_simple(self):
+        with self.assertQueryCount(__system__=6, emp=6):
+            self.env['mail.test.simple'].create({'name': 'Test'})
+
+    @users('__system__', 'emp')
+    @warmup
+    def test_write_mail_simple(self):
+        rec = self.env['mail.test.simple'].create({'name': 'Test'})
+        with self.assertQueryCount(__system__=1, emp=1):
+            rec.write({
+                'name': 'Test2',
+                'email_from': 'test@test.com',
+            })
+
+
+@tagged('mail_performance')
+class TestMailAPIPerformance(BaseMailPerformance):
+
+    def setUp(self):
+        super(TestMailAPIPerformance, self).setUp()
+        self.customer = self.env['res.partner'].with_context(self._quick_create_ctx).create({
+            'name': 'Test Customer',
+            'email': 'customer.test@example.com',
+        })
+        self.user_test = self.env['res.users'].with_context(self._quick_create_ctx).create({
+            'name': 'Paulette Testouille',
+            'login': 'paul',
+            'email': 'user.test.paulette@example.com',
+            'notification_type': 'inbox',
+            'groups_id': [(6, 0, [self.env.ref('base.group_user').id])],
+        })
+
+        # automatically follow activities, for backward compatibility concerning query count
+        self.env.ref('mail.mt_activities').write({'default': True})
+
+    def _create_test_records(self):
+        self.test_record_full = self.env['mail.test.ticket'].with_context(self._quick_create_ctx).create({
+            'name': 'TestRecord',
+            'customer_id': self.customer.id,
+            'user_id': self.user_test.id,
+            'email_from': 'nopartner.test@example.com',
+        })
+        self.test_template_full = self.env['mail.template'].create({
+            'name': 'TestTemplate',
+            'model_id': self.env['ir.model']._get('mail.test.ticket').id,
+            'subject': 'About ${object.name}',
+            'body_html': '<p>Hello ${object.name}</p>',
+            'email_from': '${object.user_id.email_formatted | safe}',
+            'partner_to': '${object.customer_id.id}',
+            'email_to': '${("%s Customer <%s>" % (object.name, object.email_from)) | safe}',
+        })
+
+    @users('__system__', 'emp')
+    @warmup
+    def test_adv_activity(self):
+        model = self.env['mail.test.activity']
+
+        with self.assertQueryCount(__system__=6, emp=6):
+            model.create({'name': 'Test'})
+
+    @users('__system__', 'emp')
+    @warmup
+    @mute_logger('odoo.models.unlink')
+    def test_adv_activity_full(self):
+        record = self.env['mail.test.activity'].create({'name': 'Test'})
+        MailActivity = self.env['mail.activity'].with_context({
+            'default_res_model': 'mail.test.activity',
+        })
+
+        with self.assertQueryCount(__system__=6, emp=6):
+            activity = MailActivity.create({
+                'summary': 'Test Activity',
+                'res_id': record.id,
+                'activity_type_id': self.env.ref('mail.mail_activity_data_todo').id,
+            })
+            #read activity_type to normalize cache between enterprise and community
+            #voip module read activity_type during create leading to one less query in enterprise on action_feedback
+            category = activity.activity_type_id.category
+
+        with self.assertQueryCount(__system__=16, emp=20):
+            activity.action_feedback(feedback='Zizisse Done !')
+
+    @users('__system__', 'emp')
+    @warmup
+    @mute_logger('odoo.models.unlink')
+    def test_adv_activity_mixin(self):
+        record = self.env['mail.test.activity'].create({'name': 'Test'})
+
+        with self.assertQueryCount(__system__=8, emp=8):
+            activity = record.action_start('Test Start')
+            #read activity_type to normalize cache between enterprise and community
+            #voip module read activity_type during create leading to one less query in enterprise on action_close
+            category = activity.activity_type_id.category
+
+        record.write({'name': 'Dupe write'})
+
+        with self.assertQueryCount(__system__=17, emp=20):
+            record.action_close('Dupe feedback')
+
+        self.assertEqual(record.activity_ids, self.env['mail.activity'])
+
+    @users('__system__', 'emp')
+    @warmup
+    @mute_logger('odoo.tests', 'odoo.addons.mail.models.mail_mail')
+    def test_mail_composer(self):
+        self._create_test_records()
+        test_record = self.env['mail.test.ticket'].browse(self.test_record_full.id)
+        customer_id = self.customer.id
+        with self.assertQueryCount(__system__=2, emp=2):
+            composer = self.env['mail.compose.message'].with_context({
+                'default_composition_mode': 'comment',
+                'default_model': test_record._name,
+                'default_res_id': test_record.id,
+            }).create({
+                'body': '<p>Test Body</p>',
+                'partner_ids': [(4, customer_id)],
+            })
+
+        with self.assertQueryCount(__system__=32, emp=39):
+            composer.send_mail()
+
+    @users('__system__', 'emp')
+    @warmup
+    @mute_logger('odoo.tests', 'odoo.addons.mail.models.mail_mail')
+    def test_mail_composer_nodelete(self):
+        self._create_test_records()
+        test_record = self.env['mail.test.ticket'].browse(self.test_record_full.id)
+        customer_id = self.customer.id
+        with self.assertQueryCount(__system__=2, emp=2):
+            composer = self.env['mail.compose.message'].with_context({
+                'default_composition_mode': 'comment',
+                'default_model': test_record._name,
+                'default_res_id': test_record.id,
+                'mail_auto_delete': False,
+            }).create({
+                'body': '<p>Test Body</p>',
+                'partner_ids': [(4, customer_id)],
+            })
+
+        with self.assertQueryCount(__system__=25, emp=32):
+            composer.send_mail()
+
+    @users('__system__', 'emp')
+    @warmup
+    @mute_logger('odoo.tests', 'odoo.addons.mail.models.mail_mail', 'odoo.models.unlink')
+    def test_mail_composer_w_template(self):
+        self._create_test_records()
+        test_record = self.env['mail.test.ticket'].browse(self.test_record_full.id)
+        test_template = self.env['mail.template'].browse(self.test_template_full.id)
+        # TODO FIXME non deterministic, last check 25 Mar 2020. Runbot at most +7 compared to local.
+        with self.assertQueryCount(__system__=12, emp=14):
+            composer = self.env['mail.compose.message'].with_context({
+                'default_composition_mode': 'comment',
+                'default_model': test_record._name,
+                'default_res_id': test_record.id,
+                'default_template_id': test_template.id,
+            }).create({})
+            composer.onchange_template_id_wrapper()
+
+        with self.assertQueryCount(__system__=33, emp=40):
+            composer.send_mail()
+
+        # remove created partner to ensure tests are the same each run
+        self.env['res.partner'].sudo().search([('email', '=', 'nopartner.test@example.com')]).unlink()
+
+    @mute_logger('odoo.tests', 'odoo.addons.mail.models.mail_mail', 'odoo.models.unlink')
+    @users('__system__', 'emp')
+    @warmup
+    def test_message_assignation_email(self):
+        self.user_test.write({'notification_type': 'email'})
+        record = self.env['mail.test.track'].create({'name': 'Test'})
+        with self.assertQueryCount(__system__=37, emp=38):
+            record.write({
+                'user_id': self.user_test.id,
+            })
+
+    @users('__system__', 'emp')
+    @warmup
+    def test_message_assignation_inbox(self):
+        record = self.env['mail.test.track'].create({'name': 'Test'})
+        with self.assertQueryCount(__system__=18, emp=21):
+            record.write({
+                'user_id': self.user_test.id,
+            })
+
+    @users('__system__', 'emp')
+    @warmup
+    def test_message_log(self):
+        record = self.env['mail.test.simple'].create({'name': 'Test'})
+
+        with self.assertQueryCount(__system__=1, emp=1):
+            record._message_log(
+                body='<p>Test _message_log</p>',
+                message_type='comment')
+
+    @users('__system__', 'emp')
+    @warmup
+    def test_message_log_with_post(self):
+        record = self.env['mail.test.simple'].create({'name': 'Test'})
+
+        with self.assertQueryCount(__system__=3, emp=6):
+            record.message_post(
+                body='<p>Test message_post as log</p>',
+                subtype_xmlid='mail.mt_note',
+                message_type='comment')
+
+    @users('__system__', 'emp')
+    @warmup
+    def test_message_post_no_notification(self):
+        record = self.env['mail.test.simple'].create({'name': 'Test'})
+
+        with self.assertQueryCount(__system__=3, emp=6):
+            record.message_post(
+                body='<p>Test Post Performances basic</p>',
+                partner_ids=[],
+                message_type='comment',
+                subtype_xmlid='mail.mt_comment')
+
+    @mute_logger('odoo.tests', 'odoo.addons.mail.models.mail_mail', 'odoo.models.unlink')
+    @users('__system__', 'emp')
+    @warmup
+    def test_message_post_one_email_notification(self):
+        record = self.env['mail.test.simple'].create({'name': 'Test'})
+
+        with self.assertQueryCount(__system__=28, emp=31):
+            record.message_post(
+                body='<p>Test Post Performances with an email ping</p>',
+                partner_ids=self.customer.ids,
+                message_type='comment',
+                subtype_xmlid='mail.mt_comment')
+
+    @users('__system__', 'emp')
+    @warmup
+    def test_message_post_one_inbox_notification(self):
+        record = self.env['mail.test.simple'].create({'name': 'Test'})
+
+        with self.assertQueryCount(__system__=12, emp=17):
+            record.message_post(
+                body='<p>Test Post Performances with an inbox ping</p>',
+                partner_ids=self.user_test.partner_id.ids,
+                message_type='comment',
+                subtype_xmlid='mail.mt_comment')
+
+    @mute_logger('odoo.models.unlink')
+    @users('__system__', 'emp')
+    @warmup
+    def test_message_subscribe_default(self):
+        record = self.env['mail.test.simple'].create({'name': 'Test'})
+
+        with self.assertQueryCount(__system__=6, emp=6):
+            record.message_subscribe(partner_ids=self.user_test.partner_id.ids)
+
+        with self.assertQueryCount(__system__=3, emp=3):
+            record.message_subscribe(partner_ids=self.user_test.partner_id.ids)
+
+    @mute_logger('odoo.models.unlink')
+    @users('__system__', 'emp')
+    @warmup
+    def test_message_subscribe_subtypes(self):
+        record = self.env['mail.test.simple'].create({'name': 'Test'})
+        subtype_ids = (self.env.ref('test_mail.st_mail_test_simple_external') | self.env.ref('mail.mt_comment')).ids
+
+        with self.assertQueryCount(__system__=5, emp=5):
+            record.message_subscribe(partner_ids=self.user_test.partner_id.ids, subtype_ids=subtype_ids)
+
+        with self.assertQueryCount(__system__=2, emp=2):
+            record.message_subscribe(partner_ids=self.user_test.partner_id.ids, subtype_ids=subtype_ids)
+
+    @mute_logger('odoo.models.unlink')
+    @users('__system__', 'emp')
+    @warmup
+    def test_message_track(self):
+        record = self.env['mail.performance.tracking'].create({'name': 'Zizizatestname'})
+        with self.assertQueryCount(__system__=3, emp=3):
+            record.write({'name': 'Zizizanewtestname'})
+            record.flush()
+
+        with self.assertQueryCount(__system__=5, emp=5):
+            record.write({'field_%s' % (i): 'Tracked Char Fields %s' % (i) for i in range(3)})
+            record.flush()
+
+        with self.assertQueryCount(__system__=6, emp=6):
+            record.write({'field_%s' % (i): 'Field Without Cache %s' % (i) for i in range(3)})
+            record.flush()
+            record.write({'field_%s' % (i): 'Field With Cache %s' % (i) for i in range(3)})
+            record.flush()
+
+
+@tagged('mail_performance')
+class TestMailComplexPerformance(BaseMailPerformance):
+
+    def setUp(self):
+        super(TestMailComplexPerformance, self).setUp()
+        self.user_portal = self.env['res.users'].with_context(self._quick_create_ctx).create({
+            'name': 'Olivia Portal',
+            'login': 'port',
+            'email': 'p.p@example.com',
+            'signature': '--\nOlivia',
+            'notification_type': 'email',
+            'groups_id': [(6, 0, [self.env.ref('base.group_portal').id])],
+        })
+
+        # setup mail gateway
+        self.env['ir.config_parameter'].sudo().set_param('mail.catchall.domain', 'example.com')
+        self.env['ir.config_parameter'].sudo().set_param('mail.catchall.alias', 'test-catchall')
+        self.env['ir.config_parameter'].sudo().set_param('mail.bounce.alias', 'test-bounce')
+
+        self.channel = self.env['mail.channel'].with_context(self._quick_create_ctx).create({
+            'name': 'Listener',
+        })
+
+        # prepare recipients to test for more realistic workload
+        self.customer = self.env['res.partner'].with_context(self._quick_create_ctx).create({
+            'name': 'Test Customer',
+            'email': 'test@example.com'
+        })
+        self.container = self.env['mail.test.container'].with_context(mail_create_nosubscribe=True).create({
+            'name': 'Test Container',
+            'customer_id': self.customer.id,
+            'alias_name': 'test-alias',
+        })
+        Partners = self.env['res.partner'].with_context(self._quick_create_ctx)
+        self.partners = self.env['res.partner']
+        for x in range(0, 10):
+            self.partners |= Partners.create({'name': 'Test %s' % x, 'email': 'test%s@example.com' % x})
+        self.container.message_subscribe(self.partners.ids, subtype_ids=[
+            self.env.ref('mail.mt_comment').id,
+            self.env.ref('test_mail.st_mail_test_container_child_full').id]
+        )
+        # `test_complex_mail_mail_send`
+        self.container.flush()
+
+    @mute_logger('odoo.tests', 'odoo.addons.mail.models.mail_mail', 'odoo.models.unlink')
+    @users('__system__', 'emp')
+    @warmup
+    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.container',
+            'res_id': self.container.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__=7, emp=7):
+            self.env['mail.mail'].sudo().browse(mail_ids).send()
+
+        self.assertEqual(mail.body_html, '<p>Test</p>')
+        self.assertEqual(mail.reply_to, formataddr(('%s %s' % (self.env.company.name, self.container.name), 'test-alias@example.com')))
+
+    @mute_logger('odoo.tests', 'odoo.addons.mail.models.mail_mail', 'odoo.models.unlink')
+    @users('__system__', 'emp')
+    @warmup
+    def test_complex_message_post(self):
+        self.container.message_subscribe(self.user_portal.partner_id.ids)
+        record = self.container.with_user(self.env.user)
+
+        with self.assertQueryCount(__system__=63, emp=64):
+            record.message_post(
+                body='<p>Test Post Performances</p>',
+                message_type='comment',
+                subtype_xmlid='mail.mt_comment')
+
+        self.assertEqual(record.message_ids[0].body, '<p>Test Post Performances</p>')
+        self.assertEqual(record.message_ids[0].notified_partner_ids, self.partners | self.user_portal.partner_id)
+
+    @mute_logger('odoo.tests', 'odoo.addons.mail.models.mail_mail', 'odoo.models.unlink')
+    @users('__system__', 'emp')
+    @warmup
+    def test_complex_message_post_template(self):
+        self.container.message_subscribe(self.user_portal.partner_id.ids)
+        record = self.container.with_user(self.env.user)
+        template_id = self.env.ref('test_mail.mail_test_container_tpl').id
+
+        with self.assertQueryCount(__system__=73, emp=75):
+            record.message_post_with_template(template_id, message_type='comment', composition_mode='comment')
+
+        self.assertEqual(record.message_ids[0].body, '<p>Adding stuff on %s</p>' % record.name)
+        self.assertEqual(record.message_ids[0].notified_partner_ids, self.partners | self.user_portal.partner_id | self.customer)
+
+    @mute_logger('odoo.tests', 'odoo.addons.mail.models.mail_mail', 'odoo.models.unlink')
+    @users('__system__', 'emp')
+    @warmup
+    def test_complex_message_subscribe(self):
+        pids = self.partners.ids
+        cids = self.channel.ids
+        subtypes = self.env.ref('mail.mt_comment') | self.env.ref('test_mail.st_mail_test_ticket_container_upd')
+        subtype_ids = subtypes.ids
+        rec = self.env['mail.test.ticket'].create({
+            'name': 'Test',
+            'container_id': False,
+            'customer_id': False,
+            'user_id': self.user_portal.id,
+        })
+        rec1 = rec.with_context(active_test=False)      # to see inactive records
+
+        self.assertEqual(rec1.message_partner_ids, self.env.user.partner_id | self.user_portal.partner_id)
+        self.assertEqual(rec1.message_channel_ids, self.env['mail.channel'])
+
+        # subscribe new followers with forced given subtypes
+        with self.assertQueryCount(__system__=8, emp=8):
+            rec.message_subscribe(
+                partner_ids=pids[:4],
+                channel_ids=cids,
+                subtype_ids=subtype_ids
+            )
+
+        self.assertEqual(rec1.message_partner_ids, self.env.user.partner_id | self.user_portal.partner_id | self.partners[:4])
+        self.assertEqual(rec1.message_channel_ids, self.channel)
+
+        # subscribe existing and new followers with force=False, meaning only some new followers will be added
+        with self.assertQueryCount(__system__=6, emp=6):
+            rec.message_subscribe(
+                partner_ids=pids[:6],
+                channel_ids=cids,
+                subtype_ids=None
+            )
+
+        self.assertEqual(rec1.message_partner_ids, self.env.user.partner_id | self.user_portal.partner_id | self.partners[:6])
+        self.assertEqual(rec1.message_channel_ids, self.channel)
+
+        # subscribe existing and new followers with force=True, meaning all will have the same subtypes
+        with self.assertQueryCount(__system__=7, emp=7):
+            rec.message_subscribe(
+                partner_ids=pids,
+                channel_ids=cids,
+                subtype_ids=subtype_ids
+            )
+
+        self.assertEqual(rec1.message_partner_ids, self.env.user.partner_id | self.user_portal.partner_id | self.partners)
+        self.assertEqual(rec1.message_channel_ids, self.channel)
+
+    @mute_logger('odoo.tests', 'odoo.addons.mail.models.mail_mail', 'odoo.models.unlink')
+    @users('__system__', 'emp')
+    @warmup
+    def test_complex_tracking_assignation(self):
+        """ Assignation performance test on already-created record """
+        rec = self.env['mail.test.ticket'].create({
+            'name': 'Test',
+            'container_id': self.container.id,
+            'customer_id': self.customer.id,
+            'user_id': self.env.uid,
+        })
+        rec1 = rec.with_context(active_test=False)      # to see inactive records
+        self.assertEqual(rec1.message_partner_ids, self.partners | self.env.user.partner_id)
+        with self.assertQueryCount(__system__=37, emp=38):
+            rec.write({'user_id': self.user_portal.id})
+        self.assertEqual(rec1.message_partner_ids, self.partners | self.env.user.partner_id | self.user_portal.partner_id)
+        # write tracking message
+        self.assertEqual(rec1.message_ids[0].subtype_id, self.env.ref('mail.mt_note'))
+        self.assertEqual(rec1.message_ids[0].notified_partner_ids, self.env['res.partner'])
+        # creation message
+        self.assertEqual(rec1.message_ids[1].subtype_id, self.env.ref('test_mail.st_mail_test_ticket_container_upd'))
+        self.assertEqual(rec1.message_ids[1].notified_partner_ids, self.partners)
+        self.assertEqual(len(rec1.message_ids), 2)
+
+    @mute_logger('odoo.tests', 'odoo.addons.mail.models.mail_mail', 'odoo.models.unlink')
+    @users('__system__', 'emp')
+    @warmup
+    def test_complex_tracking_subscription_create(self):
+        """ Creation performance test involving auto subscription, assignation, tracking with subtype and template send. """
+        container_id = self.container.id
+        customer_id = self.customer.id
+        user_id = self.user_portal.id
+
+        with self.assertQueryCount(__system__=108, emp=109):
+            rec = self.env['mail.test.ticket'].create({
+                'name': 'Test',
+                'container_id': container_id,
+                'customer_id': customer_id,
+                'user_id': user_id,
+            })
+
+        rec1 = rec.with_context(active_test=False)      # to see inactive records
+        self.assertEqual(rec1.message_partner_ids, self.partners | self.env.user.partner_id | self.user_portal.partner_id)
+        # creation message
+        self.assertEqual(rec1.message_ids[0].subtype_id, self.env.ref('test_mail.st_mail_test_ticket_container_upd'))
+        self.assertEqual(rec1.message_ids[0].notified_partner_ids, self.partners | self.user_portal.partner_id)
+        self.assertEqual(len(rec1.message_ids), 1)
+
+    @mute_logger('odoo.tests', 'odoo.addons.mail.models.mail_mail', 'odoo.models.unlink')
+    @users('__system__', 'emp')
+    @warmup
+    def test_complex_tracking_subscription_subtype(self):
+        """ Write performance test involving auto subscription, tracking with subtype """
+        rec = self.env['mail.test.ticket'].create({
+            'name': 'Test',
+            'container_id': False,
+            'customer_id': False,
+            'user_id': self.user_portal.id,
+        })
+        rec1 = rec.with_context(active_test=False)      # to see inactive records
+        self.assertEqual(rec1.message_partner_ids, self.user_portal.partner_id | self.env.user.partner_id)
+        self.assertEqual(len(rec1.message_ids), 1)
+        with self.assertQueryCount(__system__=77, emp=77):
+            rec.write({
+                'name': 'Test2',
+                'container_id': self.container.id,
+            })
+
+        self.assertEqual(rec1.message_partner_ids, self.partners | self.env.user.partner_id | self.user_portal.partner_id)
+        # write tracking message
+        self.assertEqual(rec1.message_ids[0].subtype_id, self.env.ref('test_mail.st_mail_test_ticket_container_upd'))
+        self.assertEqual(rec1.message_ids[0].notified_partner_ids, self.partners | self.user_portal.partner_id)
+        # creation message
+        self.assertEqual(rec1.message_ids[1].subtype_id, self.env.ref('mail.mt_note'))
+        self.assertEqual(rec1.message_ids[1].notified_partner_ids, self.env['res.partner'])
+        self.assertEqual(len(rec1.message_ids), 2)
+
+    @mute_logger('odoo.tests', 'odoo.addons.mail.models.mail_mail', 'odoo.models.unlink')
+    @users('__system__', 'emp')
+    @warmup
+    def test_complex_tracking_subscription_write(self):
+        """ Write performance test involving auto subscription, tracking with subtype and template send """
+        container_id = self.container.id
+        customer_id = self.customer.id
+        container2 = self.env['mail.test.container'].with_context(mail_create_nosubscribe=True).create({
+            'name': 'Test Container 2',
+            'customer_id': False,
+            'alias_name': False,
+        })
+
+        rec = self.env['mail.test.ticket'].create({
+            'name': 'Test',
+            'container_id': container2.id,
+            'customer_id': False,
+            'user_id': self.user_portal.id,
+        })
+        rec1 = rec.with_context(active_test=False)      # to see inactive records
+        self.assertEqual(rec1.message_partner_ids, self.user_portal.partner_id | self.env.user.partner_id)
+
+        with self.assertQueryCount(__system__=85, emp=85):
+            rec.write({
+                'name': 'Test2',
+                'container_id': container_id,
+                'customer_id': customer_id,
+            })
+
+        self.assertEqual(rec1.message_partner_ids, self.partners | self.env.user.partner_id | self.user_portal.partner_id)
+        # write tracking message
+        self.assertEqual(rec1.message_ids[0].subtype_id, self.env.ref('test_mail.st_mail_test_ticket_container_upd'))
+        self.assertEqual(rec1.message_ids[0].notified_partner_ids, self.partners | self.user_portal.partner_id)
+        # creation message
+        self.assertEqual(rec1.message_ids[1].subtype_id, self.env.ref('test_mail.st_mail_test_ticket_container_upd'))
+        self.assertEqual(rec1.message_ids[1].notified_partner_ids, self.user_portal.partner_id)
+        self.assertEqual(len(rec1.message_ids), 2)
+
+    @mute_logger('odoo.tests', 'odoo.addons.mail.models.mail_mail', 'odoo.models.unlink')
+    @users('__system__', 'emp')
+    @warmup
+    def test_complex_tracking_template(self):
+        """ Write performance test involving assignation, tracking with template """
+        customer_id = self.customer.id
+        self.assertTrue(self.env.registry.ready, "We need to simulate that registery is ready")
+        rec = self.env['mail.test.ticket'].create({
+            'name': 'Test',
+            'container_id': self.container.id,
+            'customer_id': False,
+            'user_id': self.user_portal.id,
+            'mail_template': self.env.ref('test_mail.mail_test_ticket_tracking_tpl').id,
+        })
+        rec1 = rec.with_context(active_test=False)      # to see inactive records
+        self.assertEqual(rec1.message_partner_ids, self.partners | self.env.user.partner_id | self.user_portal.partner_id)
+
+        with self.assertQueryCount(__system__=29, emp=30):
+            rec.write({
+                'name': 'Test2',
+                'customer_id': customer_id,
+                'user_id': self.env.uid,
+            })
+
+        # write template message (sent to customer, mass mailing kept for history)
+        self.assertEqual(rec1.message_ids[0].subtype_id, self.env['mail.message.subtype'])
+        self.assertEqual(rec1.message_ids[0].subject, 'Test Template')
+        # write tracking message
+        self.assertEqual(rec1.message_ids[1].subtype_id, self.env.ref('mail.mt_note'))
+        self.assertEqual(rec1.message_ids[1].notified_partner_ids, self.env['res.partner'])
+        # creation message
+        self.assertEqual(rec1.message_ids[2].subtype_id, self.env.ref('test_mail.st_mail_test_ticket_container_upd'))
+        self.assertEqual(rec1.message_ids[2].notified_partner_ids, self.partners | self.user_portal.partner_id)
+        self.assertEqual(len(rec1.message_ids), 3)
+
+    @mute_logger('odoo.tests', 'odoo.addons.mail.models.mail_mail', 'odoo.models.unlink')
+    @users('emp')
+    @warmup
+    def test_message_format(self):
+        """Test performance of `_message_format` and of `message_format` with
+        multiple messages with multiple attachments, different authors, various
+        notifications, and different tracking values.
+        Those messages might not make sense functionally but they are crafted to
+        cover as much of the code as possible in regard to number of queries.
+        """
+        name_field = self.env['ir.model.fields']._get(self.container._name, 'name')
+        customer_id_field = self.env['ir.model.fields']._get(self.container._name, 'customer_id')
+
+        messages = self.env['mail.message'].sudo().create([{
+            'subject': 'Test 0',
+            'body': '<p>Test 0</p>',
+            'author_id': self.partners[0].id,
+            'email_from': self.partners[0].email,
+            'model': 'mail.test.container',
+            'res_id': self.container.id,
+            'subtype_id': self.env['ir.model.data'].xmlid_to_res_id('mail.mt_comment'),
+            'attachment_ids': [
+                (0, 0, {
+                    'name': 'test file 0 - %d' % j,
+                    'datas': 'data',
+                }) for j in range(2)
+            ],
+            'notification_ids': [
+                (0, 0, {
+                    'res_partner_id': self.partners[3].id,
+                    'notification_type': 'inbox',
+                }),
+                (0, 0, {
+                    'res_partner_id': self.partners[4].id,
+                    'notification_type': 'email',
+                    'notification_status': 'exception',
+                }),
+                (0, 0, {
+                    'res_partner_id': self.partners[6].id,
+                    'notification_type': 'email',
+                    'notification_status': 'exception',
+                }),
+            ],
+            'tracking_value_ids': [
+                (0, 0, {
+                    'field': name_field.id,
+                    'field_desc': 'Name',
+                    'old_value_char': 'old 0',
+                    'new_value_char': 'new 0',
+                }),
+                (0, 0, {
+                    'field': customer_id_field.id,
+                    'field_desc': 'Customer',
+                    'old_value_integer': self.partners[7].id,
+                    'new_value_integer': self.partners[8].id,
+                }),
+            ]
+        }, {
+            'subject': 'Test 1',
+            'body': '<p>Test 1</p>',
+            'author_id': self.partners[1].id,
+            'email_from': self.partners[1].email,
+            'model': 'mail.test.container',
+            'res_id': self.container.id,
+            'subtype_id': self.env['ir.model.data'].xmlid_to_res_id('mail.mt_note'),
+            'attachment_ids': [
+                (0, 0, {
+                    'name': 'test file 1 - %d' % j,
+                    'datas': 'data',
+                }) for j in range(2)
+            ],
+            'notification_ids': [
+                (0, 0, {
+                    'res_partner_id': self.partners[5].id,
+                    'notification_type': 'inbox',
+                }),
+                (0, 0, {
+                    'res_partner_id': self.partners[6].id,
+                    'notification_type': 'email',
+                    'notification_status': 'exception',
+                }),
+            ],
+            'tracking_value_ids': [
+                (0, 0, {
+                    'field': name_field.id,
+                    'field_desc': 'Name',
+                    'old_value_char': 'old 1',
+                    'new_value_char': 'new 1',
+                }),
+                (0, 0, {
+                    'field': customer_id_field.id,
+                    'field_desc': 'Customer',
+                    'old_value_integer': self.partners[7].id,
+                    'new_value_integer': self.partners[8].id,
+                }),
+            ]
+        }])
+
+        with self.assertQueryCount(emp=5):
+            res = messages.message_format()
+            self.assertEqual(len(res), 2)
+            for message in res:
+                self.assertEqual(len(message['attachment_ids']), 2)
+
+        messages.flush()
+        messages.invalidate_cache()
+
+        with self.assertQueryCount(emp=17):
+            res = messages.message_format()
+            self.assertEqual(len(res), 2)
+            for message in res:
+                self.assertEqual(len(message['attachment_ids']), 2)
+
+    @mute_logger('odoo.tests', 'odoo.addons.mail.models.mail_mail', 'odoo.models.unlink')
+    @users('emp')
+    @warmup
+    def test_message_format_group_thread_name_by_model(self):
+        """Ensures the fetch of multiple thread names is grouped by model."""
+        records = []
+        for i in range(5):
+            records.append(self.env['mail.test.simple'].create({'name': 'Test'}))
+        records.append(self.env['mail.test.track'].create({'name': 'Test'}))
+
+        messages = self.env['mail.message'].create([{
+            'model': record._name,
+            'res_id': record.id
+        } for record in records])
+
+        with self.assertQueryCount(emp=4):
+            res = messages.message_format()
+            self.assertEqual(len(res), 6)
+
+        messages.flush()
+        messages.invalidate_cache()
+
+        with self.assertQueryCount(emp=14):
+            res = messages.message_format()
+            self.assertEqual(len(res), 6)
+
+
+@tagged('mail_performance')
+class TestMailHeavyPerformancePost(BaseMailPerformance):
+
+    def setUp(self):
+        super(TestMailHeavyPerformancePost, self).setUp()
+
+        # record
+        self.customer = self.env['res.partner'].with_context(self._quick_create_ctx).create({
+            'name': 'customer',
+            'email': 'customer@example.com',
+        })
+        self.record = self.env['mail.test.container'].with_context(mail_create_nosubscribe=True).create({
+            'name': 'Test record',
+            'customer_id': self.customer.id,
+            'alias_name': 'test-alias',
+        })
+        # followers
+        self.user_follower_email = self.env['res.users'].with_context(self._quick_create_ctx).create({
+            'name': 'user_follower_email',
+            'login': 'user_follower_email',
+            'email': 'user_follower_email@example.com',
+            'notification_type': 'email',
+            'groups_id': [(6, 0, [self.env.ref('base.group_user').id])],
+        })
+        self.user_follower_inbox = self.env['res.users'].with_context(self._quick_create_ctx).create({
+            'name': 'user_follower_inbox',
+            'login': 'user_follower_inbox',
+            'email': 'user_follower_inbox@example.com',
+            'notification_type': 'inbox',
+            'groups_id': [(6, 0, [self.env.ref('base.group_user').id])],
+        })
+        self.partner_follower = self.env['res.partner'].with_context(self._quick_create_ctx).create({
+            'name': 'partner_follower',
+            'email': 'partner_follower@example.com',
+        })
+        self.record.message_subscribe([
+            self.partner_follower.id,
+            self.user_follower_inbox.partner_id.id,
+            self.user_follower_email.partner_id.id
+        ])
+
+        # partner_ids
+        self.user_inbox = self.env['res.users'].with_context(self._quick_create_ctx).create({
+            'name': 'user_inbox',
+            'login': 'user_inbox',
+            'email': 'user_inbox@example.com',
+            'notification_type': 'inbox',
+            'groups_id': [(6, 0, [self.env.ref('base.group_user').id])],
+        })
+        self.user_email = self.env['res.users'].with_context(self._quick_create_ctx).create({
+            'name': 'user_email',
+            'login': 'user_email',
+            'email': 'user_email@example.com',
+            'notification_type': 'email',
+            'groups_id': [(6, 0, [self.env.ref('base.group_user').id])],
+        })
+        self.partner = self.env['res.partner'].with_context(self._quick_create_ctx).create({
+            'name': 'partner',
+            'email': 'partner@example.com',
+        })
+        # channels user/partner
+        self.partner_channel_inbox = self.env['res.partner'].with_context(self._quick_create_ctx).create({
+            'name': 'partner_channel_inbox',
+            'email': 'partner_channel_inbox@example.com',
+        })
+        self.partner_channel_email = self.env['res.partner'].with_context(self._quick_create_ctx).create({
+            'name': 'partner_channel_email',
+            'email': 'partner_channel_email@example.com',
+        })
+        self.user_channel_inbox = self.env['res.users'].with_context(self._quick_create_ctx).create({
+            'name': 'user_channel_inbox',
+            'login': 'user_channel_inbox',
+            'email': 'user_channel_inbox@example.com',
+            'notification_type': 'inbox',
+            'groups_id': [(6, 0, [self.env.ref('base.group_user').id])],
+        })
+        self.user_channel_email = self.env['res.users'].with_context(self._quick_create_ctx).create({
+            'name': 'user_channel_email',
+            'login': 'user_channel_email',
+            'email': 'user_channel_email@example.com',
+            'notification_type': 'inbox',
+            'groups_id': [(6, 0, [self.env.ref('base.group_user').id])],
+        })
+        # channels
+        self.channel_inbox = self.env['mail.channel'].with_context(self._quick_create_ctx).create({
+            'name': 'channel_inbox',
+            'channel_partner_ids': [(4, self.partner_channel_inbox.id), (4, self.user_channel_inbox.partner_id.id)]
+        })
+        self.channel_email = self.env['mail.channel'].with_context(self._quick_create_ctx).create({
+            'name': 'channel_email',
+            'email_send': True,
+            'channel_partner_ids': [(4, self.partner_channel_email.id), (4, self.user_channel_email.partner_id.id)]
+        })
+        self.vals = [{
+            'datas': base64.b64encode(bytes("attachement content %s" % i, 'utf-8')),
+            'name': 'fileText_test%s.txt' % i,
+            'mimetype': 'text/plain',
+            'res_model': 'mail.compose.message',
+            'res_id': 0,
+        } for i in range(3)]
+
+        self.patch(self.env.registry, 'ready', True)
+
+    @mute_logger('odoo.tests', 'odoo.addons.mail.models.mail_mail', 'odoo.models.unlink')
+    @users('emp')
+    @warmup
+    def test_complete_message_post(self):
+        # aims to cover as much features of message_post as possible
+        partner_ids = [self.user_inbox.partner_id.id, self.user_email.partner_id.id, self.partner.id]
+        channel_ids = [self.channel_inbox.id, self.channel_email.id]
+        record = self.record.with_user(self.env.user)
+        attachements = [  # not linear on number of attachements
+            ('attach tuple 1', "attachement tupple content 1"),
+            ('attach tuple 2', "attachement tupple content 2", {'cid': 'cid1'}),
+            ('attach tuple 3', "attachement tupple content 3", {'cid': 'cid2'}),
+        ]
+        self.attachements = self.env['ir.attachment'].with_user(self.env.user).create(self.vals)
+        attachement_ids = self.attachements.ids
+        with self.assertQueryCount(emp=80):
+            self.cr.sql_log = self.warm and self.cr.sql_log_count
+            record.with_context({}).message_post(
+                body='<p>Test body <img src="cid:cid1"> <img src="cid:cid2"></p>',
+                subject='Test Subject',
+                message_type='notification',
+                subtype_xmlid=None,
+                partner_ids=partner_ids,
+                channel_ids=channel_ids,
+                parent_id=False,
+                attachments=attachements,
+                attachment_ids=attachement_ids,
+                add_sign=True,
+                model_description=False,
+                mail_auto_delete=True
+            )
+            self.cr.sql_log = False
+        self.assertTrue(record.message_ids[0].body.startswith('<p>Test body <img src="/web/image/'))
+        self.assertEqual(self.attachements.mapped('res_model'), [record._name for i in range(3)])
+        self.assertEqual(self.attachements.mapped('res_id'), [record.id for i in range(3)])
+        # self.assertEqual(record.message_ids[0].notified_partner_ids, [])
diff --git a/addons/test_mail/tests/test_ui.py b/addons/test_mail/tests/test_ui.py
new file mode 100644
index 00000000..82858b52
--- /dev/null
+++ b/addons/test_mail/tests/test_ui.py
@@ -0,0 +1,10 @@
+# Part of Odoo. See LICENSE file for full copyright and licensing details.
+
+import odoo.tests
+
+
+@odoo.tests.tagged('post_install', '-at_install')
+class TestUi(odoo.tests.HttpCase):
+
+    def test_01_mail_tour(self):
+        self.start_tour("/web", 'mail_tour', login="admin")