[REF] discuss: rename variables on mail tests

rename some variables on test files to make a better sense. task-2893661 Part-of: odoo/odoo#94510
2022-08-02 23:56:53 +02:00
parent 701a775ec4
commit e3dcad0fb7
3 changed files with 102 additions and 105 deletions
@@ -27,88 +27,88 @@ class TestChannelAccessRights(MailCommon):
        cls.user_public = mail_new_test_user(cls.env, login='user_public', groups='base.group_public', name='Bert Tartignole')
        cls.user_portal = mail_new_test_user(cls.env, login='user_portal', groups='base.group_portal', name='Chell Gladys')

-        # Pigs: base group for tests
-        cls.group_groups = Channel.create({
-            'name': 'Pigs',
+        # Channel for certain group
+        cls.group_restricted_channel = Channel.create({
+            'name': 'Channel for Group',
            'public': 'groups',
            'group_public_id': cls.env.ref('base.group_user').id})
-        # Jobs: public group
-        cls.group_public = Channel.create({
-            'name': 'Jobs',
+        # Public Channel
+        cls.public_channel = Channel.create({
+            'name': 'Public Channel',
            'description': 'NotFalse',
            'public': 'public'})
-        # Private: private group
-        cls.group_private = Channel.create({
-            'name': 'Private',
+        # Group
+        cls.private_group = Channel.create({
+            'name': 'Group',
            'public': 'private'})

    @mute_logger('odoo.addons.base.models.ir_rule', 'odoo.addons.base.models.ir_model', 'odoo.models')
    @users('user_portal')
    def test_access_public(self):
-        # Read public group -> ok
-        self.env['mail.channel'].browse(self.group_public.id).read()
+        # Read public channel -> ok
+        self.env['mail.channel'].browse(self.public_channel.id).read()

-        # Read groups -> ko, restricted to employees
+        # Read channel for certain group -> ko, no access rights
        with self.assertRaises(AccessError):
-            self.env['mail.channel'].browse(self.group_groups.id).read()
-        # Read private -> ko, restricted to members
+            self.env['mail.channel'].browse(self.group_restricted_channel.id).read()
+        # Read group -> ko, no access rights
        with self.assertRaises(AccessError):
-            self.env['mail.channel'].browse(self.group_private.id).read()
+            self.env['mail.channel'].browse(self.private_group.id).read()

-        # Read a private group when being a member: ok
-        self.group_private.write({'channel_partner_ids': [(4, self.user_portal.partner_id.id)]})
-        self.env['mail.channel'].browse(self.group_private.id).read()
+        # Read a group when being a member: ok
+        self.private_group.write({'channel_partner_ids': [(4, self.user_portal.partner_id.id)]})
+        self.env['mail.channel'].browse(self.private_group.id).read()

-        # Create group: ko, no access rights
+        # Create channel: ko, no access rights
        with self.assertRaises(AccessError):
            self.env['mail.channel'].create({'name': 'Test'})

-        # Update group: ko, no access rights
+        # Update channel: ko, no access rights
        with self.assertRaises(AccessError):
-            self.env['mail.channel'].browse(self.group_public.id).write({'name': 'Broutouschnouk'})
+            self.env['mail.channel'].browse(self.public_channel.id).write({'name': 'Broutouschnouk'})

-        # Unlink group: ko, no access rights
+        # Unlink channel: ko, no access rights
        with self.assertRaises(AccessError):
-            self.env['mail.channel'].browse(self.group_public.id).unlink()
+            self.env['mail.channel'].browse(self.public_channel.id).unlink()

    @mute_logger('odoo.addons.base.models.ir_rule', 'odoo.models', 'odoo.models.unlink')
    @users('employee')
    def test_access_employee(self):
-        # Employee read employee-based group: ok
-        group_groups = self.env['mail.channel'].browse(self.group_groups.id)
-        group_groups.read()
+        # Employee read employee-based channel: ok
+        group_restricted_channel = self.env['mail.channel'].browse(self.group_restricted_channel.id)
+        group_restricted_channel.read()

-        # Employee can create a group
+        # Employee can create a channel
        new_channel = self.env['mail.channel'].create({'name': 'Test'})
        self.assertIn(new_channel.channel_partner_ids, self.partner_employee)

-        # Employee update employee-based group: ok
-        group_groups.write({'name': 'modified'})
+        # Employee update employee-based channel: ok
+        group_restricted_channel.write({'name': 'modified'})

-        # Employee unlink employee-based group: ko
+        # Employee unlink employee-based channel: ko
        with self.assertRaises(AccessError):
-            group_groups.unlink()
+            group_restricted_channel.unlink()

-        # Employee cannot read a private group
+        # Employee cannot read a group if not being a member
        with self.assertRaises(AccessError):
-            self.env['mail.channel'].browse(self.group_private.id).read()
+            self.env['mail.channel'].browse(self.private_group.id).read()

-        # Employee cannot write on private
+        # Employee cannot write on group if not being a member
        with self.assertRaises(AccessError):
-            self.env['mail.channel'].browse(self.group_private.id).write({'name': 're-modified'})
+            self.env['mail.channel'].browse(self.private_group.id).write({'name': 're-modified'})

-        # Employee cannot unlink private
+        # Employee cannot unlink group if not being a member
        with self.assertRaises(AccessError):
-            self.env['mail.channel'].browse(self.group_private.id).unlink()
+            self.env['mail.channel'].browse(self.private_group.id).unlink()

    @mute_logger('odoo.addons.base.models.ir_rule', 'odoo.models')
    @users('user_portal')
    def test_access_portal(self):
        with self.assertRaises(AccessError):
-            self.env['mail.channel'].browse(self.group_private.id).name
+            self.env['mail.channel'].browse(self.private_group.id).name

-        self.group_private.write({'channel_partner_ids': [(4, self.user_portal.partner_id.id)]})
-        group_private_portal = self.env['mail.channel'].browse(self.group_private.id)
+        self.private_group.write({'channel_partner_ids': [(4, self.user_portal.partner_id.id)]})
+        group_private_portal = self.env['mail.channel'].browse(self.private_group.id)
        group_private_portal.read(['name'])
        for message in group_private_portal.message_ids:
            message.read(['subject'])
@@ -117,7 +117,7 @@ class TestChannelAccessRights(MailCommon):
        with self.assertRaises(AccessError):
            group_private_portal.message_partner_ids

-        for partner in self.group_private.message_partner_ids:
+        for partner in self.private_group.message_partner_ids:
            if partner.id == self.user_portal.partner_id.id:
                # Chell can read her own partner record
                continue
@@ -127,24 +127,24 @@ class TestChannelAccessRights(MailCommon):
    @mute_logger('odoo.addons.base.models.ir_rule', 'odoo.addons.base.models.ir_model', 'odoo.models')
    @users('user_portal')
    def test_members(self):
-        group_public = self.env['mail.channel'].browse(self.group_public.id)
-        group_public.read(['name'])
-        self.assertFalse(group_public.is_member)
+        public_channel = self.env['mail.channel'].browse(self.public_channel.id)
+        public_channel.read(['name'])
+        self.assertFalse(public_channel.is_member)

        with self.assertRaises(AccessError):
-            group_public.write({'name': 'Better Name'})
+            public_channel.write({'name': 'Better Name'})

        with self.assertRaises(AccessError):
-            group_public.add_members(self.env.user.partner_id.ids)
+            public_channel.add_members(self.env.user.partner_id.ids)

-        group_private = self.env['mail.channel'].browse(self.group_private.id)
+        private_group = self.env['mail.channel'].browse(self.private_group.id)
        with self.assertRaises(AccessError):
-            group_private.read(['name'])
+            private_group.read(['name'])

        with self.assertRaises(AccessError):
            self.env['mail.channel.member'].create({
                'partner_id': self.env.user.partner_id.id,
-                'channel_id': group_private.id,
+                'channel_id': private_group.id,
            })


@@ -155,7 +155,7 @@ class TestChannelInternals(MailCommon):
    def setUpClass(cls):
        super(TestChannelInternals, cls).setUpClass()
        cls.test_channel = cls.env['mail.channel'].with_context(cls._test_context).create({
-            'name': 'Test',
+            'name': 'Channel',
            'channel_type': 'channel',
            'description': 'Description',
            'public': 'public',
@@ -272,25 +272,25 @@ class TestChannelInternals(MailCommon):
            'description': 'Channel to travel through time',
            'public': 'private',
        })
-        test_channel_group = self.env['mail.channel'].with_context(self._test_context).create({
+        group_restricted_channel = 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})

        self.test_channel.add_members((self.partner_employee | self.partner_employee_nomail).ids)
        test_channel_private.add_members((self.partner_employee | self.partner_employee_nomail).ids)
-        test_channel_group.add_members((self.partner_employee | self.partner_employee_nomail).ids)
+        group_restricted_channel.add_members((self.partner_employee | self.partner_employee_nomail).ids)

        # Unsubscribe archived user from the private channels, but not from public channels
        self.user_employee.active = False
        self.assertEqual(test_channel_private.channel_partner_ids, self.partner_employee_nomail)
-        self.assertEqual(test_channel_group.channel_partner_ids, self.partner_employee_nomail)
+        self.assertEqual(group_restricted_channel.channel_partner_ids, self.partner_employee_nomail)
        self.assertEqual(self.test_channel.channel_partner_ids, self.user_employee.partner_id | self.partner_employee_nomail)

        # Unsubscribe deleted user from the private channels, but not from public channels
        self.user_employee_nomail.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(group_restricted_channel.channel_partner_ids, self.env['res.partner'])
        self.assertEqual(self.test_channel.channel_partner_ids, self.user_employee.partner_id | self.partner_employee_nomail)

    @users('employee_nomail')
@@ -375,7 +375,7 @@ class TestChannelInternals(MailCommon):
            'public': 'private',
            'channel_partner_ids': [Command.link(self.user_employee.partner_id.id), Command.link(test_partner.id)],
        })
-        test_channel_group = self.env['mail.channel'].with_context(self._test_context).create({
+        group_restricted_channel = 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,
@@ -384,37 +384,37 @@ class TestChannelInternals(MailCommon):
        self.test_channel.with_context(self._test_context).write({
            'channel_partner_ids': [Command.link(self.user_employee.partner_id.id), Command.link(test_partner.id)],
        })
-        test_chat = self.env['mail.channel'].with_user(self.user_employee).with_context(self._test_context).create({
+        private_group = self.env['mail.channel'].with_user(self.user_employee).with_context(self._test_context).create({
            'name': 'test',
-            'channel_type': 'chat',
+            'channel_type': 'group',
            'public': 'private',
            'channel_partner_ids': [Command.link(self.user_employee.partner_id.id), Command.link(test_partner.id)],
        })

-        # Unsubscribe archived user from the private channels, but not from public channels and not from chat
+        # Unsubscribe archived user from the private channels, but not from public channels and not from group
        self.user_employee.active = False
-        (test_chat | self.test_channel).invalidate_recordset(['channel_partner_ids'])
+        (private_group | self.test_channel).invalidate_recordset(['channel_partner_ids'])
        self.assertEqual(test_channel_private.channel_partner_ids, test_partner)
-        self.assertEqual(test_channel_group.channel_partner_ids, test_partner)
+        self.assertEqual(group_restricted_channel.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)
+        self.assertEqual(private_group.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
+        # Unsubscribe deleted user from the private channels, but not from public channels and not from group
        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(group_restricted_channel.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)
+        self.assertEqual(private_group.channel_partner_ids, self.user_employee.partner_id | test_partner)

    @users('employee')
    def test_channel_private_unfollow(self):
        """ Test that a partner can leave (unfollow) a private channel. """
-        channel_private = self.env['mail.channel'].create({
+        group_restricted_channel = self.env['mail.channel'].create({
            'name': 'Winden caves',
            'public': 'private',
        })
-        channel_private.action_unfollow()
-        self.assertEqual(channel_private.channel_partner_ids, self.env['res.partner'])
+        group_restricted_channel.action_unfollow()
+        self.assertEqual(group_restricted_channel.channel_partner_ids, self.env['res.partner'])

    def test_channel_unfollow_should_not_post_message_if_the_partner_has_been_removed(self):
        '''
@@ -458,15 +458,15 @@ class TestChannelInternals(MailCommon):
    def test_channel_should_generate_correct_default_avatar(self):
        test_channel = self.env['mail.channel'].browse(self.env['mail.channel'].channel_create(name='Channel')['id'])
        test_channel.uuid = 'channel-uuid'
-        test_group = self.env['mail.channel'].browse(self.env['mail.channel'].create_group(partners_to=self.user_employee.partner_id.ids)['id'])
-        test_group.uuid = 'group-uuid'
+        private_group = self.env['mail.channel'].browse(self.env['mail.channel'].create_group(partners_to=self.user_employee.partner_id.ids)['id'])
+        private_group.uuid = 'group-uuid'
        bgcolor_channel = html_escape('hsl(316, 61%, 45%)')  # depends on uuid
        bgcolor_group = html_escape('hsl(17, 60%, 45%)')  # depends on uuid
        expceted_avatar_channel = (channel_avatar.replace('fill="#875a7b"', f'fill="{bgcolor_channel}"')).encode()
        expected_avatar_group = (group_avatar.replace('fill="#875a7b"', f'fill="{bgcolor_group}"')).encode()

        self.assertEqual(base64.b64decode(test_channel.avatar_128), expceted_avatar_channel)
-        self.assertEqual(base64.b64decode(test_group.avatar_128), expected_avatar_group)
+        self.assertEqual(base64.b64decode(private_group.avatar_128), expected_avatar_group)

        test_channel.image_128 = base64.b64encode(("<svg/>").encode())
        self.assertEqual(test_channel.avatar_128, test_channel.image_128)
@@ -176,7 +176,7 @@ class TestMailChannelMembers(MailCommon):
    # GROUP BASED CHANNELS
    # ------------------------------------------------------------

-    def test_channel_group(self):
+    def test_group_restricted_channel(self):
        """Test basics on group channel."""
        channel_members = self.env['mail.channel.member'].search([('channel_id', '=', self.group_channel.id)])
        self.assertFalse(channel_members)
@@ -212,7 +212,7 @@ class TestMailChannelMembers(MailCommon):
    # PUBLIC CHANNELS
    # ------------------------------------------------------------

-    def test_channel_public(self):
+    def test_public_channel(self):
        """ Test access on public channels """
        channel_members = self.env['mail.channel.member'].search([('channel_id', '=', self.public_channel.id)])
        self.assertFalse(channel_members)
@@ -262,24 +262,21 @@ class TestMessageAccess(TestMailCommon):
        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',
+        cls.group_restricted_channel = Channel.create({
+            'name': 'Channel for Groups',
            'public': 'groups',
            'group_public_id': cls.env.ref('base.group_user').id})
-        # Jobs: public group
-        cls.group_public = Channel.create({
-            'name': 'Jobs',
+        cls.public_channel = Channel.create({
+            'name': 'Public Channel',
            'description': 'NotFalse',
            'public': 'public'})
-        # Private: private gtroup
-        cls.group_private = Channel.create({
-            'name': 'Private',
+        cls.private_group = Channel.create({
+            'name': 'Group',
            'public': 'private'})
        cls.message = cls.env['mail.message'].create({
            'body': 'My Body',
            'model': 'mail.channel',
-            'res_id': cls.group_private.id,
+            'res_id': cls.private_group.id,
        })

    @mute_logger('odoo.addons.mail.models.mail_mail')
@@ -292,18 +289,18 @@ class TestMessageAccess(TestMailCommon):
            '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})
+            'model': 'mail.channel', 'res_id': self.group_restricted_channel.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,
+            'model': 'mail.channel', 'res_id': self.group_restricted_channel.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,
+            'model': 'mail.channel', 'res_id': self.group_restricted_channel.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})
+            'model': 'mail.channel', 'res_id': self.private_group.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({
@@ -314,11 +311,11 @@ class TestMessageAccess(TestMailCommon):
        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)
+        # Test: Employee: 3 messages on Channel Employee 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
+        # Test: Employee: 3 messages on Channel Employee 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)

@@ -331,7 +328,7 @@ class TestMessageAccess(TestMailCommon):
        self.assertFalse(messages)

        # Test: Portal: 2 messages (public group with a subtype)
-        self.group_pigs.write({'public': 'public'})
+        self.group_restricted_channel.write({'public': 'public'})
        messages = self.env['mail.message'].with_user(self.user_portal).search([('subject', 'like', '_ZTest')])
        self.assertEqual(messages, msg4 | msg5)

@@ -350,7 +347,7 @@ class TestMessageAccess(TestMailCommon):
            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.write({'subtype_id': self.ref('mail.mt_comment'), 'res_id': self.public_channel.id})
        self.message.with_user(self.user_portal).read(['body', 'message_type', 'subtype_id'])

    def test_mail_message_access_read_notification(self):
@@ -363,7 +360,7 @@ class TestMessageAccess(TestMailCommon):
        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 they can read message
+        # Test: Employee has access to attachment, ok because they can read message
        attachment.with_user(self.user_employee).read(['name', 'datas'])

    def test_mail_message_access_read_author(self):
@@ -371,38 +368,38 @@ class TestMessageAccess(TestMailCommon):
        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 they are allowed to read
+        self.message.write({'model': 'mail.channel', 'res_id': self.public_channel.id})
+        # Test: Employee reads the message, ok because linked to a doc they are allowed to read
        self.message.with_user(self.user_employee).read()

    # --------------------------------------------------
    # CREATE
    # --------------------------------------------------

-    @mute_logger('odoo.addons.base.models.ir_model')
+    @mute_logger('odoo.addons.base.models.ir_model', 'odoo.addons.base.models.ir_rule')
    def test_mail_message_access_create_crash_public(self):
-        # Do: Bert creates a message on Pigs -> ko, no creation rights
+        # Public creates a message on Channel for groups -> ko, no enter 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'})
+            self.env['mail.message'].with_user(self.user_public).create({'model': 'mail.channel', 'res_id': self.group_restricted_channel.id, 'body': 'Test'})

-        # Do: Bert create a message on Jobs -> ko, no creation rights
+        # Public create a message on Public Channel -> 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'})
+            self.env['mail.message'].with_user(self.user_public).create({'model': 'mail.channel', 'res_id': self.public_channel.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
+        # Do: Employee 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'})
+            self.env['mail.message'].with_user(self.user_employee).create({'model': 'mail.channel', 'res_id': self.private_group.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
+        # Do: Employee creates a message on Public Channel -> ok, write access to the related document
+        Message.create({'model': 'mail.channel', 'res_id': self.public_channel.id, 'body': 'Test'})
+        # Do: Employee creates a message on Group -> 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'})
+            Message.create({'model': 'mail.channel', 'res_id': self.private_group.id, 'body': 'Test'})

    def test_mail_message_access_create_private(self):
        self.env['mail.message'].with_user(self.user_employee).create({'body': 'Test'})
@@ -411,7 +408,7 @@ class TestMessageAccess(TestMailCommon):
        # 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})
+        self.env['mail.message'].with_user(self.user_employee).create({'model': 'mail.channel', 'res_id': self.private_group.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