[IMP] mail, *: return recordset in channel create methods

* = calendar,test_discuss_full, test_mail, test_mail_full

Methods can be downgraded to channel_info when called by RPC.
This increases the simplicity to use these methods in python.

closes odoo/odoo#139341

Related: odoo/enterprise#49326
Signed-off-by: Sébastien Theys (seb) <seb@odoo.com>

addons/calendar/models/calendar_event.py

@@ -811,14 +811,14 @@ class Meeting(models.Model):
         self.videocall_channel_id.channel_change_description(self.recurrence_id.name if self.recurrency else self.display_time)
 
     def _create_videocall_channel_id(self, name, partner_ids):
-        videocall_channel_id = self.env['discuss.channel'].create_group(partner_ids, default_display_mode='video_full_screen', name=name)
+        videocall_channel = self.env['discuss.channel'].create_group(partner_ids, default_display_mode='video_full_screen', name=name)
         # if recurrent event, set channel to all other records of the same recurrency
         if self.recurrency:
             recurrent_events_without_channel = self.env['calendar.event'].search([
                 ('recurrence_id', '=', self.recurrence_id.id), ('videocall_channel_id', '=', False)
             ])
-            recurrent_events_without_channel.videocall_channel_id = videocall_channel_id['id']
-        return videocall_channel_id['id']
+            recurrent_events_without_channel.videocall_channel_id = videocall_channel
+        return videocall_channel
 
     # ------------------------------------------------------------
     # ACTIONS

addons/mail/models/discuss/discuss_channel.py

@@ -929,6 +929,7 @@ class Channel(models.Model):
 
     # User methods
     @api.model
+    @api.returns('self', lambda channel: channel._channel_info()[0])
     def channel_get(self, partners_to, pin=True):
         """ Get the canonical private channel between some partners, create it if needed.
             To reuse an old channel (conversation), this one must be private, and contains
@@ -987,7 +988,7 @@ class Channel(models.Model):
                 'name': ', '.join(self.env['res.partner'].sudo().browse(partners_to).mapped('name')),
             })
             channel._broadcast(partners_to)
-        return channel._channel_info()[0]
+        return channel
 
     def channel_fold(self, state=None, state_count=0):
         """ Update the fold_state of the given session. In order to syncronize web browser
@@ -1138,6 +1139,7 @@ class Channel(models.Model):
         self.add_members(self.env.user.partner_id.ids)
 
     @api.model
+    @api.returns('self', lambda channel: channel._channel_info()[0])
     def channel_create(self, name, group_id):
         """ Create a channel and add the current partner, broadcast it (to make the user directly
             listen to it when polling)
@@ -1157,9 +1159,10 @@ class Channel(models.Model):
         new_channel.message_post(body=notification, message_type="notification", subtype_xmlid="mail.mt_comment")
         channel_info = new_channel._channel_info()[0]
         self.env['bus.bus']._sendone(self.env.user.partner_id, 'mail.record/insert', {"Thread": channel_info})
-        return channel_info
+        return new_channel
 
     @api.model
+    @api.returns('self', lambda channel: channel._channel_info()[0])
     def create_group(self, partners_to, default_display_mode=False, name=''):
         """ Creates a group channel.
 
@@ -1177,7 +1180,7 @@ class Channel(models.Model):
             'name': name,
         })
         channel._broadcast(partners_to)
-        return channel._channel_info()[0]
+        return channel
 
     @api.model
     def get_mention_suggestions(self, search, limit=8):

addons/mail/tests/discuss/test_discuss_channel.py

@@ -27,15 +27,15 @@ class TestChannelAccessRights(MailCommon):
         cls.user_portal = mail_new_test_user(cls.env, login='user_portal', groups='base.group_portal', name='Chell Gladys')
 
         # Channel for certain group
-        cls.group_restricted_channel = cls.env['discuss.channel'].browse(cls.env['discuss.channel'].channel_create(name='Channel for Groups', group_id=cls.env.ref('base.group_user').id)['id'])
+        cls.group_restricted_channel = cls.env['discuss.channel'].channel_create(name='Channel for Groups', group_id=cls.env.ref('base.group_user').id)
         # Public Channel
-        cls.public_channel = cls.env['discuss.channel'].browse(cls.env['discuss.channel'].channel_create(name='Public Channel', group_id=None)['id'])
+        cls.public_channel = cls.env['discuss.channel'].channel_create(name='Public Channel', group_id=None)
         # Group
-        cls.private_group = cls.env['discuss.channel'].browse(cls.env['discuss.channel'].create_group(partners_to=cls.user_employee.partner_id.ids, name="Group")['id'])
+        cls.private_group = cls.env['discuss.channel'].create_group(partners_to=cls.user_employee.partner_id.ids, name="Group")
         # Chat
-        cls.chat_user_employee = cls.env['discuss.channel'].browse(cls.env['discuss.channel'].channel_get(cls.user_employee.partner_id.ids)['id'])
-        cls.chat_user_employee_1 = cls.env['discuss.channel'].browse(cls.env['discuss.channel'].channel_get(cls.user_employee_1.partner_id.ids)['id'])
-        cls.chat_user_portal = cls.env['discuss.channel'].browse(cls.env['discuss.channel'].channel_get(cls.user_portal.partner_id.ids)['id'])
+        cls.chat_user_employee = cls.env['discuss.channel'].channel_get(cls.user_employee.partner_id.ids)
+        cls.chat_user_employee_1 = cls.env['discuss.channel'].channel_get(cls.user_employee_1.partner_id.ids)
+        cls.chat_user_portal = cls.env['discuss.channel'].channel_get(cls.user_portal.partner_id.ids)
 
     @mute_logger('odoo.addons.base.models.ir_rule', 'odoo.addons.base.models.ir_model', 'odoo.models')
     @users('user_public')
@@ -208,7 +208,7 @@ class TestChannelInternals(MailCommon):
     @classmethod
     def setUpClass(cls):
         super().setUpClass()
-        cls.test_channel = cls.env['discuss.channel'].browse(cls.env['discuss.channel'].with_context(cls._test_context).channel_create(name='Channel', group_id=None)['id'])
+        cls.test_channel = cls.env['discuss.channel'].with_context(cls._test_context).channel_create(name='Channel', group_id=None)
         cls.test_partner = cls.env['res.partner'].with_context(cls._test_context).create({
             'name': 'Test Partner',
             'email': 'test_customer@example.com',
@@ -248,8 +248,7 @@ class TestChannelInternals(MailCommon):
     @users('employee')
     @mute_logger('odoo.addons.mail.models.mail_mail', 'odoo.models.unlink')
     def test_channel_chat_message_post_should_update_last_interest_dt(self):
-        channel_info = self.env['discuss.channel'].with_user(self.user_admin).channel_get((self.partner_employee | self.user_admin.partner_id).ids)
-        chat = self.env['discuss.channel'].with_user(self.user_admin).browse(channel_info['id'])
+        chat = self.env['discuss.channel'].with_user(self.user_admin).channel_get((self.partner_employee | self.user_admin.partner_id).ids)
         post_time = fields.Datetime.now()
         # Mocks the return value of field.Datetime.now(),
         # so we can see if the `last_interest_dt` is updated correctly
@@ -284,8 +283,7 @@ class TestChannelInternals(MailCommon):
     @mute_logger('odoo.addons.mail.models.mail_mail', 'odoo.models.unlink')
     def test_channel_recipients_chat(self):
         """ Posting a message on a chat should not send emails """
-        channel_info = self.env['discuss.channel'].with_user(self.user_admin).channel_get((self.partner_employee | self.user_admin.partner_id).ids)
-        chat = self.env['discuss.channel'].with_user(self.user_admin).browse(channel_info['id'])
+        chat = self.env['discuss.channel'].with_user(self.user_admin).channel_get((self.partner_employee | self.user_admin.partner_id).ids)
         with self.mock_mail_gateway():
             with self.with_user('employee'):
                 new_msg = chat.message_post(body="Test", message_type='comment', subtype_xmlid='mail.mt_comment')
@@ -307,7 +305,7 @@ class TestChannelInternals(MailCommon):
     @mute_logger('odoo.models.unlink')
     def test_channel_user_synchronize(self):
         """Archiving / deleting a user should automatically unsubscribe related partner from group restricted channels"""
-        group_restricted_channel = self.env['discuss.channel'].browse(self.env['discuss.channel'].channel_create(name='Sic Mundus', group_id=self.env.ref('base.group_user').id)['id'])
+        group_restricted_channel = self.env['discuss.channel'].channel_create(name='Sic Mundus', group_id=self.env.ref('base.group_user').id)
 
         self.test_channel.add_members((self.partner_employee | self.partner_employee_nomail).ids)
         group_restricted_channel.add_members((self.partner_employee | self.partner_employee_nomail).ids)
@@ -325,47 +323,45 @@ class TestChannelInternals(MailCommon):
     @users('employee_nomail')
     def test_channel_info_get(self):
         # `channel_get` should return a new channel the first time a partner is given
-        initial_channel_info = self.env['discuss.channel'].channel_get(partners_to=self.test_partner.ids)
+        initial_channel_info = self.env['discuss.channel'].channel_get(partners_to=self.test_partner.ids)._channel_info()[0]
         # shape of channelMembers is [('ADD', data...)], [0][1] accesses the data
         self.assertEqual({m['persona']['id'] for m in initial_channel_info['channelMembers'][0][1]}, {self.partner_employee_nomail.id, self.test_partner.id})
 
         # `channel_get` should return the existing channel every time the same partner is given
-        same_channel_info = self.env['discuss.channel'].channel_get(partners_to=self.test_partner.ids)
+        same_channel_info = self.env['discuss.channel'].channel_get(partners_to=self.test_partner.ids)._channel_info()[0]
         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 = self.env['discuss.channel'].channel_get(partners_to=(self.partner_employee_nomail + self.test_partner).ids)
+        together_channel_info = self.env['discuss.channel'].channel_get(partners_to=(self.partner_employee_nomail + self.test_partner).ids)._channel_info()[0]
         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 = self.env['discuss.channel'].channel_get(partners_to=self.partner_employee_nomail.ids)
+        solo_channel_info = self.env['discuss.channel'].channel_get(partners_to=self.partner_employee_nomail.ids)._channel_info()[0]
         self.assertNotEqual(solo_channel_info['id'], initial_channel_info['id'])
         # shape of channelMembers is [('ADD', data...)], [0][1] accesses the data
         self.assertEqual({m['persona']['id'] for m in solo_channel_info['channelMembers'][0][1]}, {self.partner_employee_nomail.id})
 
         # `channel_get` should return the existing channel every time the current partner is given
-        same_solo_channel_info = self.env['discuss.channel'].channel_get(partners_to=self.partner_employee_nomail.ids)
+        same_solo_channel_info = self.env['discuss.channel'].channel_get(partners_to=self.partner_employee_nomail.ids)._channel_info()[0]
         self.assertEqual(same_solo_channel_info['id'], solo_channel_info['id'])
 
     # `channel_get` will pin the channel by default and thus last interest will be updated.
     @users('employee')
     def test_channel_info_get_should_update_last_interest_dt(self):
-        # create the channel via `channel_get`
         self.env['discuss.channel'].channel_get(partners_to=self.partner_admin.ids)
 
         retrieve_time = datetime(2021, 1, 1, 0, 0)
         with patch.object(fields.Datetime, 'now', lambda: retrieve_time):
             # `last_interest_dt` should be updated again when `channel_get` is called
             # because `channel_pin` is called.
-            channel_info = self.env['discuss.channel'].channel_get(partners_to=self.partner_admin.ids)
+            channel_info = self.env['discuss.channel'].channel_get(partners_to=self.partner_admin.ids)._channel_info()[0]
         self.assertEqual(channel_info['last_interest_dt'], retrieve_time.strftime(DEFAULT_SERVER_DATETIME_FORMAT))
 
     @users('employee')
     def test_channel_info_seen(self):
         """ In case of concurrent channel_seen RPC, ensure the oldest call has no effect. """
-        channel_info = self.env['discuss.channel'].with_user(self.user_admin).channel_get((self.partner_employee | self.user_admin.partner_id).ids)
-        chat = self.env['discuss.channel'].with_user(self.user_admin).browse(channel_info['id'])
+        chat = self.env['discuss.channel'].with_user(self.user_admin).channel_get((self.partner_employee | self.user_admin.partner_id).ids)
         msg_1 = self._add_messages(chat, 'Body1', author=self.user_employee.partner_id)
         msg_2 = self._add_messages(chat, 'Body2', author=self.user_employee.partner_id)
 
@@ -431,10 +427,10 @@ class TestChannelInternals(MailCommon):
     @mute_logger('odoo.models.unlink')
     def test_channel_private_unfollow(self):
         """ Test that a partner can leave (unfollow) a channel/group/chat. """
-        group_restricted_channel = self.env['discuss.channel'].browse(self.env['discuss.channel'].channel_create(name='Channel for Groups', group_id=self.env.ref('base.group_user').id)['id'])
-        public_channel = self.env['discuss.channel'].browse(self.env['discuss.channel'].channel_create(name='Channel for Everyone', group_id=None)['id'])
-        private_group = self.env['discuss.channel'].browse(self.env['discuss.channel'].create_group(partners_to=self.user_employee.partner_id.ids, name="Group")['id'])
-        chat_user_current = self.env['discuss.channel'].browse(self.env['discuss.channel'].channel_get(self.env.user.partner_id.ids)['id'])
+        group_restricted_channel = self.env['discuss.channel'].channel_create(name='Channel for Groups', group_id=self.env.ref('base.group_user').id)
+        public_channel = self.env['discuss.channel'].channel_create(name='Channel for Everyone', group_id=None)
+        private_group = self.env['discuss.channel'].create_group(partners_to=self.user_employee.partner_id.ids, name="Group")
+        chat_user_current = self.env['discuss.channel'].channel_get(self.env.user.partner_id.ids)
 
         group_restricted_channel.add_members(self.env.user.partner_id.id)
         public_channel.add_members(self.env.user.partner_id.id)
@@ -489,9 +485,9 @@ class TestChannelInternals(MailCommon):
         self.assertEqual(messages_1, messages_2)
 
     def test_channel_should_generate_correct_default_avatar(self):
-        test_channel = self.env['discuss.channel'].browse(self.env['discuss.channel'].channel_create(name='Channel', group_id=self.env.ref('base.group_user').id)['id'])
+        test_channel = self.env['discuss.channel'].channel_create(name='Channel', group_id=self.env.ref('base.group_user').id)
         test_channel.uuid = 'channel-uuid'
-        private_group = self.env['discuss.channel'].browse(self.env['discuss.channel'].create_group(partners_to=self.user_employee.partner_id.ids)['id'])
+        private_group = self.env['discuss.channel'].create_group(partners_to=self.user_employee.partner_id.ids)
         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
@@ -575,13 +571,13 @@ class TestChannelInternals(MailCommon):
         with self.with_user('employee'):
             initial_channel_info = self.env['discuss.channel'].with_context(
                 allowed_company_ids=self.company_admin.ids
-            ).channel_get(self.partner_employee_c2.ids)
+            ).channel_get(self.partner_employee_c2.ids)._channel_info()[0]
             self.assertTrue(initial_channel_info, 'should be able to chat with multi company user')
 
     @users('employee')
     def test_create_chat_channel_should_only_pin_the_channel_for_the_current_user(self):
         chat = self.env['discuss.channel'].channel_get(partners_to=self.test_partner.ids)
-        member_of_current_user = self.env['discuss.channel.member'].search([('channel_id', '=', chat['id']), ('partner_id', '=', self.env.user.partner_id.id)])
-        member_of_correspondent = self.env['discuss.channel.member'].search([('channel_id', '=', chat['id']), ('partner_id', '=', self.test_partner.id)])
+        member_of_current_user = self.env['discuss.channel.member'].search([('channel_id', '=', chat.id), ('partner_id', '=', self.env.user.partner_id.id)])
+        member_of_correspondent = self.env['discuss.channel.member'].search([('channel_id', '=', chat.id), ('partner_id', '=', self.test_partner.id)])
         self.assertTrue(member_of_current_user.is_pinned)
         self.assertFalse(member_of_correspondent.is_pinned)

addons/mail/tests/discuss/test_discuss_channel_as_guest.py

@@ -28,13 +28,13 @@ class TestMailPublicPage(HttpCase):
         )
         guest = self.env['mail.guest'].create({'name': 'Guest Mario'})
 
-        self.channel = self.env['discuss.channel'].browse(self.env['discuss.channel'].channel_create(group_id=None, name='Test channel')['id'])
+        self.channel = self.env['discuss.channel'].channel_create(group_id=None, name='Test channel')
         self.channel.allow_public_upload = True
         self.channel.add_members(portal_user.partner_id.ids)
         self.channel.add_members(internal_user.partner_id.ids)
         self.channel.add_members(guest_ids=[guest.id])
 
-        self.group = self.env['discuss.channel'].browse(self.env['discuss.channel'].create_group(partners_to=(internal_user + portal_user).partner_id.ids, name="Test group")['id'])
+        self.group = self.env['discuss.channel'].create_group(partners_to=(internal_user + portal_user).partner_id.ids, name="Test group")
         self.group.add_members(guest_ids=[guest.id])
         self.group.allow_public_upload = True
 

addons/mail/tests/discuss/test_discuss_channel_member.py

@@ -56,7 +56,7 @@ class TestDiscussChannelMembers(MailCommon):
             'channel_type': 'channel',
             'group_public_id': cls.secret_group.id,
         })
-        cls.public_channel = cls.env['discuss.channel'].browse(cls.env['discuss.channel'].channel_create(group_id=None, name='Public channel of user 1')['id'])
+        cls.public_channel = cls.env['discuss.channel'].channel_create(group_id=None, name='Public channel of user 1')
         (cls.group | cls.group_restricted_channel | cls.public_channel).channel_member_ids.unlink()
 
     # ------------------------------------------------------------
@@ -243,7 +243,7 @@ class TestDiscussChannelMembers(MailCommon):
     # ------------------------------------------------------------
 
     def test_unread_counter_with_message_post(self):
-        channel_as_user_1 = self.env['discuss.channel'].browse(self.env['discuss.channel'].with_user(self.user_1).channel_create(group_id=None, name='Public channel')['id'])
+        channel_as_user_1 = self.env['discuss.channel'].with_user(self.user_1).channel_create(group_id=None, name='Public channel')
         channel_as_user_1.with_user(self.user_1).add_members(self.user_1.partner_id.ids)
         channel_as_user_1.with_user(self.user_1).add_members(self.user_2.partner_id.ids)
         channel_1_rel_user_2 = self.env['discuss.channel.member'].search([
@@ -260,8 +260,8 @@ class TestDiscussChannelMembers(MailCommon):
         self.assertEqual(channel_1_rel_user_2.message_unread_counter, 1, "should have 1 unread message after someone else posted a message")
 
     def test_unread_counter_with_message_post_multi_channel(self):
-        channel_1_as_user_1 = self.env['discuss.channel'].with_user(self.user_1).browse(self.env['discuss.channel'].with_user(self.user_1).channel_create(group_id=None, name='wololo channel')['id'])
-        channel_2_as_user_2 = self.env['discuss.channel'].with_user(self.user_2).browse(self.env['discuss.channel'].with_user(self.user_2).channel_create(group_id=None, name='walala channel')['id'])
+        channel_1_as_user_1 = self.env['discuss.channel'].with_user(self.user_1).channel_create(group_id=None, name='wololo channel')
+        channel_2_as_user_2 = self.env['discuss.channel'].with_user(self.user_2).channel_create(group_id=None, name='walala channel')
         channel_1_as_user_1.add_members(self.user_2.partner_id.ids)
         channel_2_as_user_2.add_members(self.user_1.partner_id.ids)
         channel_2_as_user_2.add_members(self.user_3.partner_id.ids)

addons/mail/tests/discuss/test_rtc.py

@@ -17,7 +17,7 @@ class TestChannelInternals(MailCommon):
     @mute_logger('odoo.models.unlink')
     def test_01_join_call(self):
         """Join call should remove existing sessions, remove invitation, create a new session, and return data."""
-        channel = self.env['discuss.channel'].browse(self.env['discuss.channel'].channel_create(name='Test Channel', group_id=self.env.ref('base.group_user').id)['id'])
+        channel = self.env['discuss.channel'].channel_create(name='Test Channel', group_id=self.env.ref('base.group_user').id)
         channel_member = channel.sudo().channel_member_ids.filtered(lambda channel_member: channel_member.partner_id == self.user_employee.partner_id)
         channel_member._rtc_join_call()
         self.env['bus.bus'].sudo().search([]).unlink()
@@ -96,7 +96,7 @@ class TestChannelInternals(MailCommon):
     @mute_logger('odoo.models.unlink')
     def test_10_start_call_in_chat_should_invite_all_members_to_call(self):
         test_user = self.env['res.users'].sudo().create({'name': "Test User", 'login': 'test'})
-        channel = self.env['discuss.channel'].browse(self.env['discuss.channel'].channel_get(partners_to=(self.user_employee.partner_id + test_user.partner_id).ids)['id'])
+        channel = self.env['discuss.channel'].channel_get(partners_to=(self.user_employee.partner_id + test_user.partner_id).ids)
         channel_member = channel.sudo().channel_member_ids.filtered(lambda channel_member: channel_member.partner_id == self.user_employee.partner_id)
         channel_member_test_user = channel.sudo().channel_member_ids.filtered(lambda channel_member: channel_member.partner_id == test_user.partner_id)
         channel_member._rtc_join_call()
@@ -176,7 +176,7 @@ class TestChannelInternals(MailCommon):
     def test_11_start_call_in_group_should_invite_all_members_to_call(self):
         test_user = self.env['res.users'].sudo().create({'name': "Test User", 'login': 'test'})
         test_guest = self.env['mail.guest'].sudo().create({'name': "Test Guest"})
-        channel = self.env['discuss.channel'].browse(self.env['discuss.channel'].create_group(partners_to=(self.user_employee.partner_id + test_user.partner_id).ids)['id'])
+        channel = self.env['discuss.channel'].create_group(partners_to=(self.user_employee.partner_id + test_user.partner_id).ids)
         channel.add_members(guest_ids=test_guest.ids)
         channel_member_test_user = channel.sudo().channel_member_ids.filtered(lambda channel_member: channel_member.partner_id == test_user.partner_id)
         channel_member_test_guest = channel.sudo().channel_member_ids.filtered(lambda channel_member: channel_member.guest_id == test_guest)
@@ -306,7 +306,7 @@ class TestChannelInternals(MailCommon):
     def test_20_join_call_should_cancel_pending_invitations(self):
         test_user = self.env['res.users'].sudo().create({'name': "Test User", 'login': 'test'})
         test_guest = self.env['mail.guest'].sudo().create({'name': "Test Guest"})
-        channel = self.env['discuss.channel'].browse(self.env['discuss.channel'].create_group(partners_to=(self.user_employee.partner_id + test_user.partner_id).ids)['id'])
+        channel = self.env['discuss.channel'].create_group(partners_to=(self.user_employee.partner_id + test_user.partner_id).ids)
         channel.add_members(guest_ids=test_guest.ids)
         channel_member = channel.sudo().channel_member_ids.filtered(lambda channel_member: channel_member.partner_id == self.user_employee.partner_id)
         channel_member._rtc_join_call()
@@ -450,7 +450,7 @@ class TestChannelInternals(MailCommon):
     def test_21_leave_call_should_cancel_pending_invitations(self):
         test_user = self.env['res.users'].sudo().create({'name': "Test User", 'login': 'test'})
         test_guest = self.env['mail.guest'].sudo().create({'name': "Test Guest"})
-        channel = self.env['discuss.channel'].browse(self.env['discuss.channel'].create_group(partners_to=(self.user_employee.partner_id + test_user.partner_id).ids)['id'])
+        channel = self.env['discuss.channel'].create_group(partners_to=(self.user_employee.partner_id + test_user.partner_id).ids)
         channel.add_members(guest_ids=test_guest.ids)
         channel_member = channel.sudo().channel_member_ids.filtered(lambda channel_member: channel_member.partner_id == self.user_employee.partner_id)
         channel_member._rtc_join_call()
@@ -542,7 +542,7 @@ class TestChannelInternals(MailCommon):
     def test_25_lone_call_participant_leaving_call_should_cancel_pending_invitations(self):
         test_user = self.env['res.users'].sudo().create({'name': "Test User", 'login': 'test'})
         test_guest = self.env['mail.guest'].sudo().create({'name': "Test Guest"})
-        channel = self.env['discuss.channel'].browse(self.env['discuss.channel'].create_group(partners_to=(self.user_employee.partner_id + test_user.partner_id).ids)['id'])
+        channel = self.env['discuss.channel'].create_group(partners_to=(self.user_employee.partner_id + test_user.partner_id).ids)
         channel.add_members(guest_ids=test_guest.ids)
         channel_member = channel.sudo().channel_member_ids.filtered(lambda channel_member: channel_member.partner_id == self.user_employee.partner_id)
         channel_member_test_user = channel.sudo().channel_member_ids.filtered(lambda channel_member: channel_member.partner_id == test_user.partner_id)
@@ -632,7 +632,7 @@ class TestChannelInternals(MailCommon):
     def test_30_add_members_while_in_call_should_invite_new_members_to_call(self):
         test_user = self.env['res.users'].sudo().create({'name': "Test User", 'login': 'test'})
         test_guest = self.env['mail.guest'].sudo().create({'name': "Test Guest"})
-        channel = self.env['discuss.channel'].browse(self.env['discuss.channel'].create_group(partners_to=self.user_employee.partner_id.ids)['id'])
+        channel = self.env['discuss.channel'].create_group(partners_to=self.user_employee.partner_id.ids)
         channel_member = channel.sudo().channel_member_ids.filtered(lambda member: member.partner_id == self.user_employee.partner_id)
         channel_member._rtc_join_call()
         self.env['bus.bus'].sudo().search([]).unlink()
@@ -748,7 +748,7 @@ class TestChannelInternals(MailCommon):
     @users('employee')
     @mute_logger('odoo.models.unlink')
     def test_40_leave_call_should_remove_existing_sessions_of_user_in_channel_and_return_data(self):
-        channel = self.env['discuss.channel'].browse(self.env['discuss.channel'].create_group(partners_to=self.user_employee.partner_id.ids)['id'])
+        channel = self.env['discuss.channel'].create_group(partners_to=self.user_employee.partner_id.ids)
         channel_member = channel.sudo().channel_member_ids.filtered(lambda channel_member: channel_member.partner_id == self.user_employee.partner_id)
         channel_member._rtc_join_call()
         self.env['bus.bus'].sudo().search([]).unlink()
@@ -778,7 +778,7 @@ class TestChannelInternals(MailCommon):
     @users('employee')
     @mute_logger('odoo.models.unlink')
     def test_50_garbage_collect_should_remove_old_sessions_and_notify_data(self):
-        channel = self.env['discuss.channel'].browse(self.env['discuss.channel'].create_group(partners_to=self.user_employee.partner_id.ids)['id'])
+        channel = self.env['discuss.channel'].create_group(partners_to=self.user_employee.partner_id.ids)
         channel_member = channel.sudo().channel_member_ids.filtered(lambda channel_member: channel_member.partner_id == self.user_employee.partner_id)
         channel_member._rtc_join_call()
         channel_member.rtc_session_ids.flush_model()
@@ -811,7 +811,7 @@ class TestChannelInternals(MailCommon):
     @users('employee')
     @mute_logger('odoo.models.unlink')
     def test_51_action_disconnect_should_remove_selected_session_and_notify_data(self):
-        channel = self.env['discuss.channel'].browse(self.env['discuss.channel'].create_group(partners_to=self.user_employee.partner_id.ids)['id'])
+        channel = self.env['discuss.channel'].create_group(partners_to=self.user_employee.partner_id.ids)
         channel_member = channel.sudo().channel_member_ids.filtered(lambda channel_member: channel_member.partner_id == self.user_employee.partner_id)
         channel_member._rtc_join_call()
         self.env['bus.bus'].sudo().search([]).unlink()
@@ -842,7 +842,7 @@ class TestChannelInternals(MailCommon):
     @users('employee')
     @mute_logger('odoo.models.unlink')
     def test_60_rtc_sync_sessions_should_gc_and_return_outdated_and_active_sessions(self):
-        channel = self.env['discuss.channel'].browse(self.env['discuss.channel'].create_group(partners_to=self.user_employee.partner_id.ids)['id'])
+        channel = self.env['discuss.channel'].create_group(partners_to=self.user_employee.partner_id.ids)
         channel_member = channel.sudo().channel_member_ids.filtered(lambda channel_member: channel_member.partner_id == self.user_employee.partner_id)
         join_call_values = channel_member._rtc_join_call()
         test_guest = self.env['mail.guest'].sudo().create({'name': "Test Guest"})

addons/test_discuss_full/tests/test_performance.py

@@ -67,22 +67,22 @@ class TestDiscussFullPerformance(HttpCase):
         self.env['discuss.channel'].sudo().search([('id', '!=', self.channel_general.id)]).unlink()
         self.user_root = self.env.ref('base.user_root')
         # create public channels
-        self.channel_channel_public_1 = self.env['discuss.channel'].browse(self.env['discuss.channel'].channel_create(name='public channel 1', group_id=None)['id'])
+        self.channel_channel_public_1 = self.env['discuss.channel'].channel_create(name='public channel 1', group_id=None)
         self.channel_channel_public_1.add_members((self.users[0] + self.users[2] + self.users[3] + self.users[4] + self.users[8]).partner_id.ids)
-        self.channel_channel_public_2 = self.env['discuss.channel'].browse(self.env['discuss.channel'].channel_create(name='public channel 2', group_id=None)['id'])
+        self.channel_channel_public_2 = self.env['discuss.channel'].channel_create(name='public channel 2', group_id=None)
         self.channel_channel_public_2.add_members((self.users[0] + self.users[2] + self.users[4] + self.users[7] + self.users[9]).partner_id.ids)
         # create group-restricted channels
-        self.channel_channel_group_1 = self.env['discuss.channel'].browse(self.env['discuss.channel'].channel_create(name='group restricted channel 1', group_id=self.env.ref('base.group_user').id)['id'])
+        self.channel_channel_group_1 = self.env['discuss.channel'].channel_create(name='group restricted channel 1', group_id=self.env.ref('base.group_user').id)
         self.channel_channel_group_1.add_members((self.users[0] + self.users[2] + self.users[3] + self.users[6] + self.users[12]).partner_id.ids)
-        self.channel_channel_group_2 = self.env['discuss.channel'].browse(self.env['discuss.channel'].channel_create(name='group restricted channel 2', group_id=self.env.ref('base.group_user').id)['id'])
+        self.channel_channel_group_2 = self.env['discuss.channel'].channel_create(name='group restricted channel 2', group_id=self.env.ref('base.group_user').id)
         self.channel_channel_group_2.add_members((self.users[0] + self.users[2] + self.users[6] + self.users[7] + self.users[13]).partner_id.ids)
         # create chats
-        self.channel_chat_1 = self.env['discuss.channel'].browse(self.env['discuss.channel'].channel_get((self.users[0] + self.users[14]).partner_id.ids)['id'])
-        self.channel_chat_2 = self.env['discuss.channel'].browse(self.env['discuss.channel'].channel_get((self.users[0] + self.users[15]).partner_id.ids)['id'])
-        self.channel_chat_3 = self.env['discuss.channel'].browse(self.env['discuss.channel'].channel_get((self.users[0] + self.users[2]).partner_id.ids)['id'])
-        self.channel_chat_4 = self.env['discuss.channel'].browse(self.env['discuss.channel'].channel_get((self.users[0] + self.users[3]).partner_id.ids)['id'])
+        self.channel_chat_1 = self.env['discuss.channel'].channel_get((self.users[0] + self.users[14]).partner_id.ids)
+        self.channel_chat_2 = self.env['discuss.channel'].channel_get((self.users[0] + self.users[15]).partner_id.ids)
+        self.channel_chat_3 = self.env['discuss.channel'].channel_get((self.users[0] + self.users[2]).partner_id.ids)
+        self.channel_chat_4 = self.env['discuss.channel'].channel_get((self.users[0] + self.users[3]).partner_id.ids)
         # create groups
-        self.channel_group_1 = self.env['discuss.channel'].browse(self.env['discuss.channel'].create_group((self.users[0] + self.users[12]).partner_id.ids)['id'])
+        self.channel_group_1 = self.env['discuss.channel'].create_group((self.users[0] + self.users[12]).partner_id.ids)
         # create livechats
         im_livechat_channel = self.env['im_livechat.channel'].sudo().create({'name': 'support', 'user_ids': [Command.link(self.users[0].id)]})
         self.env['bus.presence'].create({'user_id': self.users[0].id, 'status': 'online'})  # make available for livechat (ignore leave)

addons/test_mail/tests/test_mail_message.py

@@ -332,9 +332,9 @@ class TestMessageAccess(MailCommon):
         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')
 
-        cls.group_restricted_channel = cls.env['discuss.channel'].browse(cls.env['discuss.channel'].channel_create(name='Channel for Groups', group_id=cls.env.ref('base.group_user').id)['id'])
-        cls.public_channel = cls.env['discuss.channel'].browse(cls.env['discuss.channel'].channel_create(name='Public Channel', group_id=None)['id'])
-        cls.private_group = cls.env['discuss.channel'].browse(cls.env['discuss.channel'].create_group(partners_to=cls.user_employee_1.partner_id.ids, name="Group")['id'])
+        cls.group_restricted_channel = cls.env['discuss.channel'].channel_create(name='Channel for Groups', group_id=cls.env.ref('base.group_user').id)
+        cls.public_channel = cls.env['discuss.channel'].channel_create(name='Public Channel', group_id=None)
+        cls.private_group = cls.env['discuss.channel'].create_group(partners_to=cls.user_employee_1.partner_id.ids, name="Group")
         cls.message = cls.env['mail.message'].create({
             'body': 'My Body',
             'model': 'discuss.channel',

addons/test_mail_full/tests/test_web_push.py

@@ -50,7 +50,7 @@ class TestWebPushNotification(SMSCommon):
             'name': 'Direct Message',
         })
 
-        cls.group_channel = cls.env['discuss.channel'].browse(cls.env['discuss.channel'].channel_create(name='Channel', group_id=None)['id'])
+        cls.group_channel = cls.env['discuss.channel'].channel_create(name='Channel', group_id=None)
         cls.group_channel.add_members((cls.user_email + cls.user_inbox).partner_id.ids)
 
         cls.env['mail.partner.device'].get_web_push_vapid_public_key()