diff --git a/addons/mail/tests/common.py b/addons/mail/tests/common.py
index d0ff1259e20..b28e04edd19 100644
--- a/addons/mail/tests/common.py
+++ b/addons/mail/tests/common.py
@@ -193,7 +193,7 @@ class MockEmail(common.BaseCase):
             if all(p in mail.recipient_ids for p in recipients):
                 break
         else:
-            raise AssertionError('mail.mail not found for message %s / status %s / recipients %s' % (mail_message, status, recipients.ids))
+            raise AssertionError('mail.mail not found for message %s / status %s / recipients %s / author %s' % (mail_message, status, recipients.ids, author))
         return mail
 
     def _find_mail_mail_wemail(self, email_to, status, mail_message=None, author=None):
@@ -222,15 +222,21 @@ class MockEmail(common.BaseCase):
         mail = self._find_mail(author, recipients, mail_message)
         self.assertEqual(mail.state, 'exception')
 
-    def assertMailMail(self, recipients, status, check_mail_mail=True, mail_message=None, author=None, email_values=None, fields_values=None):
+    def assertMailMail(self, recipients, status,
+                       check_mail_mail=True, mail_message=None, author=None,
+                       content=None, fields_values=None, email_values=None):
         if check_mail_mail:
-            mail = self._find_mail_mail_wpartners(recipients, status, mail_message=mail_message, author=author)
-            self.assertTrue(bool(mail))
+            found_mail = self._find_mail_mail_wpartners(recipients, status, mail_message=mail_message, author=author)
+            self.assertTrue(bool(found_mail))
+            if content:
+                self.assertIn(content, found_mail.body_html)
             for fname, fvalue in (fields_values or {}).items():
-                self.assertEqual(mail[fname], fvalue)
+                self.assertEqual(
+                    found_mail[fname], fvalue,
+                    'Mail: expected %s for %s, got %s' % (fvalue, fname, found_mail[fname]))
         if status == 'sent':
             for recipient in recipients:
-                self.assertSentEmail(author, [recipient], **email_values)
+                self.assertSentEmail(email_values['email_from'] if email_values and email_values.get('email_from') else author, [recipient], **(email_values or {}))
 
     def assertMailMailWEmails(self, emails, status, content, fields_values=None):
         """ Will check in self._new_mails to find a sent mail.mail. To use with
@@ -302,6 +308,15 @@ class MockEmail(common.BaseCase):
         for val in ['reply_to', 'subject', 'references', 'attachments']:
             if val in expected:
                 self.assertEqual(expected[val], sent_mail[val], 'Value for %s: expected %s, received %s' % (val, expected[val], sent_mail[val]))
+        if 'attachments_info' in values:
+            attachments = sent_mail['attachments']
+            for attachment_info in values['attachments_info']:
+                attachment = next(attach for attach in attachments if attach[0] == attachment_info['name'])
+                if attachment_info.get('raw'):
+                    self.assertEqual(attachment[1], attachment_info['raw'])
+                if attachment_info.get('type'):
+                    self.assertEqual(attachment[2], attachment_info['type'])
+            self.assertEqual(len(values['attachments_info']), len(attachments))
         for val in ['body']:
             if val in expected:
                 self.assertHtmlEqual(expected[val], sent_mail[val], 'Value for %s: expected %s, received %s' % (val, expected[val], sent_mail[val]))
@@ -655,6 +670,29 @@ class MailCase(MockEmail):
 
         return bus_notifs
 
+    def assertNotified(self, message, recipients_info, is_complete=False):
+        """ Lightweight check for notifications (mail.notification).
+
+        :param recipients_info: list notified recipients: [
+          {'partner': res.partner record (may be empty),
+           'type': notification_type to check,
+           'is_read': is_read to check,
+          }, {...}]
+        """
+        notifications = self._new_notifs.filtered(lambda notif: notif in message.notification_ids)
+        if is_complete:
+            self.assertEqual(len(notifications), len(recipients_info))
+        for rinfo in recipients_info:
+            recipient_notif = next(
+                (notif
+                 for notif in notifications
+                 if notif.res_partner_id == rinfo['partner']
+                ), False
+            )
+            self.assertTrue(recipient_notif)
+            self.assertEqual(recipient_notif.is_read, rinfo['is_read'])
+            self.assertEqual(recipient_notif.notification_type, rinfo['type'])
+
     def assertTracking(self, message, data):
         tracking_values = message.sudo().tracking_value_ids
         for field_name, value_type, old_value, new_value in data:
diff --git a/addons/test_mail/tests/__init__.py b/addons/test_mail/tests/__init__.py
index bd72e0bf019..15d441d888c 100644
--- a/addons/test_mail/tests/__init__.py
+++ b/addons/test_mail/tests/__init__.py
@@ -10,7 +10,6 @@ from . import test_mail_mail
 from . import test_mail_gateway
 from . import test_mail_template
 from . import test_mail_thread_internals
-from . import test_message_composer
 from . import test_message_management
 from . import test_message_post
 from . import test_message_track
diff --git a/addons/test_mail/tests/test_mail_composer.py b/addons/test_mail/tests/test_mail_composer.py
index 589f4105176..e22a875a5a6 100644
--- a/addons/test_mail/tests/test_mail_composer.py
+++ b/addons/test_mail/tests/test_mail_composer.py
@@ -3,7 +3,10 @@
 
 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
@@ -18,9 +21,14 @@ class TestMailComposer(TestMailCommon, TestRecipients):
         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='inbox', email='eglantine@example.com',
+            notification_type='email', email='eglantine@example.com',
             name='Eglantine Employee', signature='--\nEglantine')
         cls.partner_employee_2 = cls.user_employee_2.partner_id
 
@@ -37,6 +45,7 @@ class TestMailComposer(TestMailCommon, TestRecipients):
             '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>'
 
@@ -54,9 +63,10 @@ class TestMailComposer(TestMailCommon, TestRecipients):
             '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 | 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):
@@ -102,7 +112,59 @@ class TestComposerForm(TestMailComposer):
         # 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_records._name)
+        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):
@@ -139,6 +201,7 @@ class TestComposerInternals(TestMailComposer):
         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])])
@@ -161,6 +224,7 @@ class TestComposerInternals(TestMailComposer):
             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)
 
@@ -207,9 +271,9 @@ class TestComposerInternals(TestMailComposer):
             self.assertEqual(composer.email_from, self.test_from)
 
     @users('employee')
-    def test_mail_composer_content_comment(self):
-        """ Test content management (subject, body, server) in comment mode.
-        Template update is also tested. """
+    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)
@@ -314,3 +378,426 @@ class TestComposerInternals(TestMailComposer):
             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_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',
+                            check_mail_mail=True,
+                            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',
+                            check_mail_mail=True,
+                            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', check_mail_mail=True,
+                                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',
+                                check_mail_mail=True,
+                                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_message_composer.py b/addons/test_mail/tests/test_message_composer.py
deleted file mode 100644
index ea6aa91803f..00000000000
--- a/addons/test_mail/tests/test_message_composer.py
+++ /dev/null
@@ -1,345 +0,0 @@
-# -*- 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.tests.common import TestMailCommon, TestRecipients
-from odoo.addons.test_mail.models.test_mail_models import MailTestSimple
-from odoo.tests import tagged
-from odoo.tools import mute_logger
-
-
-@tagged('mail_composer')
-class TestComposer(TestMailCommon, TestRecipients):
-    """ Test Composer integration and results """
-
-    @classmethod
-    def setUpClass(cls):
-        super(TestComposer, cls).setUpClass()
-        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)
-
-    @mute_logger('odoo.addons.mail.models.mail_mail')
-    def test_composer_comment(self):
-        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,
-        }).with_user(self.user_employee).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)
-
-    @mute_logger('odoo.addons.mail.models.mail_mail')
-    def test_composer_comment_parent(self):
-        parent = self.test_record.message_post(body='Test')
-
-        self.env['mail.compose.message'].with_context({
-            'default_composition_mode': 'comment',
-            'default_parent_id': parent.id
-        }).with_user(self.user_employee).create({
-            'body': '<p>Mega</p>',
-        }).send_mail()
-
-        message = self.test_record.message_ids[0]
-        self.assertEqual(message.body, '<p>Mega</p>')
-        self.assertEqual(message.parent_id, parent)
-
-    @mute_logger('odoo.addons.mail.models.mail_mail')
-    def test_composer_mass_mail(self):
-        test_record_2 = self.env['mail.test.simple'].with_context(self._test_context).create({'name': 'Test2'})
-
-        composer = self.env['mail.compose.message'].with_context({
-            'default_composition_mode': 'mass_mail',
-            'default_model': self.test_record._name,
-            'default_res_id': False,
-            'active_ids': [self.test_record.id, test_record_2.id]
-        }).with_user(self.user_employee).create({
-            'subject': 'Testing ${object.name}',
-            'body': '<p>${object.name}</p>',
-            'partner_ids': [(4, self.partner_1.id), (4, self.partner_2.id)]
-        })
-        composer.with_context({
-            'default_res_id': -1,
-            'active_ids': [self.test_record.id, test_record_2.id]
-        }).send_mail()
-
-        # check mail_mail
-        mails = self.env['mail.mail'].sudo().search([('subject', 'ilike', 'Testing')])
-        for mail in mails:
-            self.assertEqual(mail.recipient_ids, self.partner_1 | self.partner_2,
-                             'compose wizard: mail_mail mass mailing: mail.mail in mass mail incorrect recipients')
-
-        # check message on test_record
-        message1 = self.test_record.message_ids[0]
-        self.assertEqual(message1.subject, 'Testing %s' % self.test_record.name)
-        self.assertEqual(message1.body, '<p>%s</p>' % self.test_record.name)
-
-        # check message on test_record_2
-        message1 = test_record_2.message_ids[0]
-        self.assertEqual(message1.subject, 'Testing %s' % test_record_2.name)
-        self.assertEqual(message1.body, '<p>%s</p>' % test_record_2.name)
-
-    @mute_logger('odoo.addons.mail.models.mail_mail')
-    def test_composer_mass_mail_active_domain(self):
-        test_record_2 = self.env['mail.test.simple'].with_context(self._test_context).create({'name': 'Test2'})
-
-        self.env['mail.compose.message'].with_context({
-            'default_composition_mode': 'mass_mail',
-            'default_model': self.test_record._name,
-            'default_use_active_domain': True,
-            'active_ids': [self.test_record.id],
-            'active_domain': [('name', 'in', ['%s' % self.test_record.name, '%s' % test_record_2.name])],
-        }).with_user(self.user_employee).create({
-            'subject': 'From Composer Test',
-            'body': '${object.name}',
-        }).send_mail()
-
-        self.assertEqual(self.test_record.message_ids[0].subject, 'From Composer Test')
-        self.assertEqual(test_record_2.message_ids[0].subject, 'From Composer Test')
-
-    @mute_logger('odoo.addons.mail.models.mail_mail')
-    def test_message_compose_mass_mail_no_active_domain(self):
-        test_record_2 = self.env['mail.test.simple'].with_context(self._test_context).create({'name': 'Test2'})
-
-        self.env['mail.compose.message'].with_context({
-            'default_composition_mode': 'mass_mail',
-            'default_model': self.test_record._name,
-            'default_use_active_domain': False,
-            'active_ids': [self.test_record.id],
-            'active_domain': [('name', 'in', ['%s' % self.test_record.name, '%s' % test_record_2.name])],
-        }).with_user(self.user_employee).create({
-            'subject': 'From Composer Test',
-            'body': '${object.name}',
-        }).send_mail()
-
-        self.assertEqual(self.test_record.message_ids[0].subject, 'From Composer Test')
-        self.assertFalse(test_record_2.message_ids.ids)
-
-    @mute_logger('odoo.addons.mail.models.mail_mail')
-    def test_message_compose_portal_ok(self):
-        portal_user = self._create_portal_user()
-
-        with patch.object(MailTestSimple, 'check_access_rights', return_value=True):
-            ComposerPortal = self.env['mail.compose.message'].with_user(portal_user)
-
-            ComposerPortal.with_context({
-                'default_composition_mode': 'comment',
-                'default_model': self.test_record._name,
-                'default_res_id': self.test_record.id,
-            }).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)
-
-            ComposerPortal.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)
-
-
-@tagged('mail_composer')
-class TestComposerWTpl(TestMailCommon, TestRecipients):
-
-    @classmethod
-    def setUpClass(cls):
-        super(TestComposerWTpl, 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_composer_w_template(self):
-        composer = self.env['mail.compose.message'].with_user(self.user_employee).with_context({
-            'default_composition_mode': 'comment',
-            'default_model': 'mail.test.simple',
-            'default_res_id': self.test_record.id,
-            'default_template_id': self.email_template.id,
-        }).create({'subject': 'Forget me subject', 'body': 'Dummy body'})
-
-        # perform onchange and send emails
-        values = composer.onchange_template_id(self.email_template.id, 'comment', self.test_record._name, self.test_record.id)['value']
-        composer.write(values)
-        with self.mock_mail_gateway(mail_unlink_sent=True):
-            composer.send_mail()
-
-        new_partners = self.env['res.partner'].search([('email', 'in', [self.email_1, self.email_2])])
-        self.assertMailMail(
-            [self.partner_1, self.partner_2, new_partners[0], new_partners[1], self.partner_admin],
-            'sent',
-            author=self.user_employee.partner_id,
-            mail_message=False,
-            check_mail_mail=False,
-            email_values={
-                'subject': 'About %s' % self.test_record.name,
-                'body_content': self.test_record.name,
-                'attachments': [
-                    ('first.txt', b'My first attachment', 'text/plain'),
-                    ('second.txt', b'My second attachment', 'text/plain')
-                ]
-            }
-        )
-
-    def test_composer_template_onchange_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."""
-
-        composer = self.env['mail.compose.message'].with_context(default_attachment_ids=[]).create({})
-        report_template = self.env.ref('web.action_report_externalpreview')
-        template_1 = self.email_template.copy({
-            'report_template': report_template.id,
-        })
-        template_2 = self.email_template.copy({
-            'attachment_ids': False,
-            'report_template': report_template.id,
-        })
-
-        onchange_templates = [template_1, template_2, template_1, False]
-        attachments_onchange = [composer.attachment_ids]
-        # template_1 has two static attachments and one dynamically generated report,
-        # template_2 only has the report, so we should get 3, 1, 3 attachments
-        attachment_numbers = [0, 3, 1, 3, 0]
-
-        for template in onchange_templates:
-            onchange = composer.onchange_template_id(
-                template.id if template else False, 'comment', self.test_record._name, self.test_record.id
-            )
-            composer.update(onchange['value'])
-            attachments_onchange.append(composer.attachment_ids)
-
-        self.assertEqual(
-            [len(attachments) for attachments in attachments_onchange],
-            attachment_numbers,
-        )
-
-        self.assertTrue(
-            len(attachments_onchange[1] & attachments_onchange[3]) == 2,
-            "The two static attachments on the template should be common to the two onchanges"
-        )
-
-    @mute_logger('odoo.addons.mail.models.mail_mail')
-    def test_composer_w_template_mass_mailing(self):
-        test_record_2 = self.env['mail.test.simple'].with_context(self._test_context).create({'name': 'Test2', 'email_from': 'laurie.poiret@example.com'})
-
-        composer = self.env['mail.compose.message'].with_user(self.user_employee).with_context({
-            'default_composition_mode': 'mass_mail',
-            # 'default_notify': True,
-            'default_notify': False,
-            'default_model': 'mail.test.simple',
-            'default_res_id': self.test_record.id,
-            'default_template_id': self.email_template.id,
-            'active_ids': [self.test_record.id, test_record_2.id]
-        }).create({})
-        values = composer.onchange_template_id(self.email_template.id, 'mass_mail', 'mail.test.simple', self.test_record.id)['value']
-        composer.write(values)
-        with self.mock_mail_gateway(mail_unlink_sent=True):
-            composer.send_mail()
-
-        new_partners = self.env['res.partner'].search([('email', 'in', [self.email_1, self.email_2])])
-        # hack to use assertEmails
-        self._mails_record1 = [dict(mail) for mail in self._mails if '%s-%s' % (self.test_record.id, self.test_record._name) in mail['message_id']]
-        self._mails_record2 = [dict(mail) for mail in self._mails if '%s-%s' % (test_record_2.id, test_record_2._name) in mail['message_id']]
-
-        self._mails = self._mails_record1
-        self.assertMailMail(
-            [self.partner_1, self.partner_2, new_partners[0], new_partners[1], self.partner_admin],
-            'sent',
-            author=self.user_employee.partner_id,
-            mail_message=False,
-            check_mail_mail=False,
-            email_values={
-                'subject': 'About %s' % self.test_record.name,
-                'body_content': self.test_record.name,
-                'attachments': [
-                    ('first.txt', b'My first attachment', 'text/plain'),
-                    ('second.txt', b'My second attachment', 'text/plain')
-                ]
-            }
-        )
-
-        self._mails = self._mails_record2
-        self.assertMailMail(
-            [self.partner_1, self.partner_2, new_partners[0], new_partners[1], self.partner_admin],
-            'sent',
-            author=self.user_employee.partner_id,
-            mail_message=False,
-            check_mail_mail=False,
-            email_values={
-                'subject': 'About %s' % test_record_2.name,
-                'body_content': test_record_2.name,
-                'attachments': [
-                    ('first.txt', b'My first attachment', 'text/plain'),
-                    ('second.txt', b'My second attachment', 'text/plain')
-                ]
-            }
-        )
-
-        message_1 = self.test_record.message_ids[0]
-        message_2 = test_record_2.message_ids[0]
-
-        # messages effectively posted
-        self.assertEqual(message_1.subject, 'About %s' % self.test_record.name)
-        self.assertEqual(message_2.subject, 'About %s' % test_record_2.name)
-        self.assertIn(self.test_record.name, message_1.body)
-        self.assertIn(test_record_2.name, message_2.body)
-
-    def test_composer_template_save(self):
-        self.env['mail.compose.message'].with_context({
-            'default_composition_mode': 'comment',
-            'default_model': 'mail.test.simple',
-            'default_res_id': self.test_record.id,
-        }).create({
-            'subject': 'Forget me subject',
-            'body': '<p>Dummy body</p>'
-        }).save_as_template()
-        # Test: email_template subject, body_html, model
-        last_template = self.env['mail.template'].search([('model', '=', 'mail.test.simple'), ('subject', '=', 'Forget me subject')], limit=1)
-        self.assertEqual(last_template.body_html, '<p>Dummy body</p>', 'email_template incorrect body_html')