[FIX] *: sudo() -> with_user()

1 files changed, 56 insertions, 56 deletions

diff --git a/addons/website_forum/tests/test_forum.py b/addons/website_forum/tests/test_forum.py
index 91d72c5dff5..ab05ff00392 100644
--- a/addons/website_forum/tests/test_forum.py
+++ b/addons/website_forum/tests/test_forum.py
@@ -18,23 +18,23 @@ class TestForum(TestForumCommon):
 
         # create some posts
         self.admin_post = self.post
-        self.portal_post = Post.sudo(self.user_portal).create({
+        self.portal_post = Post.with_user(self.user_portal).create({
             'name': 'Post from Portal User',
             'content': 'I am not a bird.',
             'forum_id': self.forum.id,
         })
-        self.employee_post = Post.sudo(self.user_employee).create({
+        self.employee_post = Post.with_user(self.user_employee).create({
             'name': 'Post from Employee User',
             'content': 'I am not a bird.',
             'forum_id': self.forum.id,
         })
 
         # vote on some posts
-        self.employee_vote_on_admin_post = Vote.sudo(self.user_employee).create({
+        self.employee_vote_on_admin_post = Vote.with_user(self.user_employee).create({
             'post_id': self.admin_post.id,
             'vote': '1',
         })
-        self.portal_vote_on_admin_post = Vote.sudo(self.user_portal).create({
+        self.portal_vote_on_admin_post = Vote.with_user(self.user_portal).create({
             'post_id': self.admin_post.id,
             'vote': '1',
         })
@@ -49,45 +49,45 @@ class TestForum(TestForumCommon):
 
         # One should not be able to modify someone else's vote
         with self.assertRaises(UserError):
-            self.admin_vote_on_portal_post.sudo(self.user_employee).write({
+            self.admin_vote_on_portal_post.with_user(self.user_employee).write({
                 'vote': '-1',
             })
         with self.assertRaises(UserError):
-            self.admin_vote_on_employee_post.sudo(self.user_portal).write({
+            self.admin_vote_on_employee_post.with_user(self.user_portal).write({
                 'vote': '-1',
             })
 
         # One should not be able to give his vote to someone else
-        self.employee_vote_on_admin_post.sudo(self.user_employee).write({
+        self.employee_vote_on_admin_post.with_user(self.user_employee).write({
             'user_id': 1,
         })
         self.assertEqual(self.employee_vote_on_admin_post.user_id, self.user_employee, 'User employee should not be able to give its vote ownership to someone else')
         # One should not be able to change his vote's post to a post of his own (would be self voting)
         with self.assertRaises(UserError):
-            self.employee_vote_on_admin_post.sudo(self.user_employee).write({
+            self.employee_vote_on_admin_post.with_user(self.user_employee).write({
                 'post_id': self.employee_post.id,
             })
 
         # One should not be able to give his vote to someone else
-        self.portal_vote_on_admin_post.sudo(self.user_portal).write({
+        self.portal_vote_on_admin_post.with_user(self.user_portal).write({
             'user_id': 1,
         })
         self.assertEqual(self.portal_vote_on_admin_post.user_id, self.user_portal, 'User portal should not be able to give its vote ownership to someone else')
         # One should not be able to change his vote's post to a post of his own (would be self voting)
         with self.assertRaises(UserError):
-            self.portal_vote_on_admin_post.sudo(self.user_portal).write({
+            self.portal_vote_on_admin_post.with_user(self.user_portal).write({
                 'post_id': self.portal_post.id,
             })
 
         # One should not be able to vote for its own post
         with self.assertRaises(UserError):
-            Vote.sudo(self.user_employee).create({
+            Vote.with_user(self.user_employee).create({
                 'post_id': self.employee_post.id,
                 'vote': '1',
             })
         # One should not be able to vote for its own post
         with self.assertRaises(UserError):
-            Vote.sudo(self.user_portal).create({
+            Vote.with_user(self.user_portal).create({
                 'post_id': self.portal_post.id,
                 'vote': '1',
             })
@@ -96,27 +96,27 @@ class TestForum(TestForumCommon):
             with self.assertRaises(IntegrityError):
                 with self.cr.savepoint():
                     # One should not be able to vote more than once on a same post
-                    Vote.sudo(self.user_employee).create({
+                    Vote.with_user(self.user_employee).create({
                         'post_id': self.admin_post.id,
                         'vote': '1',
                     })
             with self.assertRaises(IntegrityError):
                 with self.cr.savepoint():
                     # One should not be able to vote more than once on a same post
-                    Vote.sudo(self.user_employee).create({
+                    Vote.with_user(self.user_employee).create({
                         'post_id': self.admin_post.id,
                         'vote': '1',
                     })
 
         # One should not be able to create a vote for someone else
-        new_employee_vote = Vote.sudo(self.user_employee).create({
+        new_employee_vote = Vote.with_user(self.user_employee).create({
             'post_id': self.portal_post.id,
             'user_id': 1,
             'vote': '1',
         })
         self.assertEqual(new_employee_vote.user_id, self.user_employee, 'Creating a vote for someone else should not be allowed. It should create it for yourself instead')
         # One should not be able to create a vote for someone else
-        new_portal_vote = Vote.sudo(self.user_portal).create({
+        new_portal_vote = Vote.with_user(self.user_portal).create({
             'post_id': self.employee_post.id,
             'user_id': 1,
             'vote': '1',
@@ -129,14 +129,14 @@ class TestForum(TestForumCommon):
 
         # Public user asks a question: not allowed
         with self.assertRaises(AccessError):
-            Post.sudo(self.user_public).create({
+            Post.with_user(self.user_public).create({
                 'name': " Question ?",
                 'forum_id': self.forum.id,
             })
 
         # Portal user asks a question with tags: not allowed, unsufficient karma
         with self.assertRaises(KarmaError):
-            Post.sudo(self.user_portal).create({
+            Post.with_user(self.user_portal).create({
                 'name': " Q_0",
                 'forum_id': self.forum.id,
                 'tag_ids': [(0, 0, {'name': 'Tag0', 'forum_id': self.forum.id})]
@@ -144,7 +144,7 @@ class TestForum(TestForumCommon):
 
         # Portal user asks a question with tags: ok if enough karma
         self.user_portal.karma = KARMA['tag_create']
-        Post.sudo(self.user_portal).create({
+        Post.with_user(self.user_portal).create({
             'name': " Q0",
             'forum_id': self.forum.id,
             'tag_ids': [(0, 0, {'name': 'Tag1', 'forum_id': self.forum.id})]
@@ -152,7 +152,7 @@ class TestForum(TestForumCommon):
         self.assertEqual(self.user_portal.karma, KARMA['tag_create'], 'website_forum: wrong karma generation when asking question')
 
         self.user_portal.karma = KARMA['post']
-        Post.sudo(self.user_portal).create({
+        Post.with_user(self.user_portal).create({
             'name': " Q0",
             'forum_id': self.forum.id,
             'tag_ids': [(0, 0, {'name': 'Tag42', 'forum_id': self.forum.id})]
@@ -165,7 +165,7 @@ class TestForum(TestForumCommon):
 
         # Answers its own question: not allowed, unsufficient karma
         with self.assertRaises(KarmaError):
-            Post.sudo(self.user_employee).create({
+            Post.with_user(self.user_employee).create({
                 'name': " A0",
                 'forum_id': self.forum.id,
                 'parent_id': self.post.id,
@@ -173,7 +173,7 @@ class TestForum(TestForumCommon):
 
         # Answers on question: ok if enough karma
         self.user_employee.karma = KARMA['ans']
-        Post.sudo(self.user_employee).create({
+        Post.with_user(self.user_employee).create({
             'name': " A0",
             'forum_id': self.forum.id,
             'parent_id': self.post.id,
@@ -184,7 +184,7 @@ class TestForum(TestForumCommon):
     def test_vote_crash(self):
         Post = self.env['forum.post']
         self.user_employee.karma = KARMA['ans']
-        emp_answer = Post.sudo(self.user_employee).create({
+        emp_answer = Post.with_user(self.user_employee).create({
             'name': 'TestAnswer',
             'forum_id': self.forum.id,
             'parent_id': self.post.id})
@@ -195,19 +195,19 @@ class TestForum(TestForumCommon):
 
         # not enough karma
         with self.assertRaises(KarmaError):
-            self.post.sudo(self.user_portal).vote(upvote=True)
+            self.post.with_user(self.user_portal).vote(upvote=True)
 
     def test_vote(self):
         self.post.create_uid.karma = KARMA['ask']
         self.user_portal.karma = KARMA['upv']
-        self.post.sudo(self.user_portal).vote(upvote=True)
+        self.post.with_user(self.user_portal).vote(upvote=True)
         self.assertEqual(self.post.create_uid.karma, KARMA['ask'] + KARMA['gen_que_upv'], 'website_forum: wrong karma generation of upvoted question author')
 
     @mute_logger('odoo.addons.base.models.ir_model', 'odoo.models')
     def test_downvote_crash(self):
         Post = self.env['forum.post']
         self.user_employee.karma = KARMA['ans']
-        emp_answer = Post.sudo(self.user_employee).create({
+        emp_answer = Post.with_user(self.user_employee).create({
             'name': 'TestAnswer',
             'forum_id': self.forum.id,
             'parent_id': self.post.id})
@@ -218,112 +218,112 @@ class TestForum(TestForumCommon):
 
         # not enough karma
         with self.assertRaises(KarmaError):
-            self.post.sudo(self.user_portal).vote(upvote=False)
+            self.post.with_user(self.user_portal).vote(upvote=False)
 
     def test_downvote(self):
         self.post.create_uid.karma = 50
         self.user_portal.karma = KARMA['dwv']
-        self.post.sudo(self.user_portal).vote(upvote=False)
+        self.post.with_user(self.user_portal).vote(upvote=False)
         self.assertEqual(self.post.create_uid.karma, 50 + KARMA['gen_que_dwv'], 'website_forum: wrong karma generation of downvoted question author')
 
     def test_comment_crash(self):
         with self.assertRaises(KarmaError):
-            self.post.sudo(self.user_portal).message_post(body='Should crash', message_type='comment')
+            self.post.with_user(self.user_portal).message_post(body='Should crash', message_type='comment')
 
     def test_comment(self):
-        self.post.sudo(self.user_employee).message_post(body='Test0', message_type='notification')
+        self.post.with_user(self.user_employee).message_post(body='Test0', message_type='notification')
         self.user_employee.karma = KARMA['com_all']
-        self.post.sudo(self.user_employee).message_post(body='Test1', message_type='comment')
+        self.post.with_user(self.user_employee).message_post(body='Test1', message_type='comment')
         self.assertEqual(len(self.post.message_ids), 4, 'website_forum: wrong behavior of message_post')
 
     def test_flag_a_post(self):
         Post = self.env['forum.post']
         self.user_portal.karma = KARMA['ask']
-        post = Post.sudo(self.user_portal).create({
+        post = Post.with_user(self.user_portal).create({
             'name': "Q0",
             'forum_id': self.forum.id,
         })
 
         # portal user flags a post: not allowed, unsufficient karma
         with self.assertRaises(KarmaError):
-            post.sudo(self.user_portal).flag()
+            post.with_user(self.user_portal).flag()
 
         # portal user flags a post: ok if enough karma
         self.user_portal.karma = KARMA['flag']
         post.state = 'active'
-        post.sudo(self.user_portal).flag()
+        post.with_user(self.user_portal).flag()
         self.assertEqual(post.state, 'flagged', 'website_forum: wrong state when flagging a post')
 
     def test_validate_a_post(self):
         Post = self.env['forum.post']
         self.user_portal.karma = KARMA['ask']
-        post = Post.sudo(self.user_portal).create({
+        post = Post.with_user(self.user_portal).create({
             'name': "Q0",
             'forum_id': self.forum.id,
         })
 
         # portal user validate a post: not allowed, unsufficient karma
         with self.assertRaises(KarmaError):
-            post.sudo(self.user_portal).validate()
+            post.with_user(self.user_portal).validate()
 
         # portal user validate a pending post
         self.user_portal.karma = KARMA['moderate']
         post.state = 'pending'
         init_karma = post.create_uid.karma
-        post.sudo(self.user_portal).validate()
+        post.with_user(self.user_portal).validate()
         self.assertEqual(post.state, 'active', 'website_forum: wrong state when validate a post after pending')
         self.assertEqual(post.create_uid.karma, init_karma + KARMA['gen_que_new'], 'website_forum: wrong karma when validate a post after pending')
 
         # portal user validate a flagged post: ok if enough karma
         self.user_portal.karma = KARMA['moderate']
         post.state = 'flagged'
-        post.sudo(self.user_portal).validate()
+        post.with_user(self.user_portal).validate()
         self.assertEqual(post.state, 'active', 'website_forum: wrong state when validate a post after flagged')
 
         # portal user validate an offensive post: ok if enough karma
         self.user_portal.karma = KARMA['moderate']
         post.state = 'offensive'
         init_karma = post.create_uid.karma
-        post.sudo(self.user_portal).validate()
+        post.with_user(self.user_portal).validate()
         self.assertEqual(post.state, 'active', 'website_forum: wrong state when validate a post after offensive')
 
     def test_refuse_a_post(self):
         Post = self.env['forum.post']
         self.user_portal.karma = KARMA['ask']
-        post = Post.sudo(self.user_portal).create({
+        post = Post.with_user(self.user_portal).create({
             'name': "Q0",
             'forum_id': self.forum.id,
         })
 
         # portal user validate a post: not allowed, unsufficient karma
         with self.assertRaises(KarmaError):
-            post.sudo(self.user_portal).refuse()
+            post.with_user(self.user_portal).refuse()
 
         # portal user validate a pending post
         self.user_portal.karma = KARMA['moderate']
         post.state = 'pending'
         init_karma = post.create_uid.karma
-        post.sudo(self.user_portal).refuse()
+        post.with_user(self.user_portal).refuse()
         self.assertEqual(post.moderator_id, self.user_portal, 'website_forum: wrong moderator_id when refusing')
         self.assertEqual(post.create_uid.karma, init_karma, 'website_forum: wrong karma when refusing a post')
 
     def test_mark_a_post_as_offensive(self):
         Post = self.env['forum.post']
         self.user_portal.karma = KARMA['ask']
-        post = Post.sudo(self.user_portal).create({
+        post = Post.with_user(self.user_portal).create({
             'name': "Q0",
             'forum_id': self.forum.id,
         })
 
         # portal user mark a post as offensive: not allowed, unsufficient karma
         with self.assertRaises(KarmaError):
-            post.sudo(self.user_portal).mark_as_offensive(12)
+            post.with_user(self.user_portal).mark_as_offensive(12)
 
         # portal user mark a post as offensive
         self.user_portal.karma = KARMA['moderate']
         post.state = 'flagged'
         init_karma = post.create_uid.karma
-        post.sudo(self.user_portal).mark_as_offensive(12)
+        post.with_user(self.user_portal).mark_as_offensive(12)
         self.assertEqual(post.state, 'offensive', 'website_forum: wrong state when marking a post as offensive')
         self.assertEqual(post.create_uid.karma, init_karma + KARMA['gen_ans_flag'], 'website_forum: wrong karma when marking a post as offensive')
 
@@ -331,34 +331,34 @@ class TestForum(TestForumCommon):
         Post = self.env['forum.post']
 
         # converting a question does nothing
-        new_msg = self.post.sudo(self.user_portal).convert_answer_to_comment()
+        new_msg = self.post.with_user(self.user_portal).convert_answer_to_comment()
         self.assertEqual(new_msg.id, False, 'website_forum: question to comment conversion failed')
         self.assertEqual(Post.search([('name', '=', 'TestQuestion')])[0].forum_id.name, 'TestForum', 'website_forum: question to comment conversion failed')
 
         with self.assertRaises(KarmaError):
-            self.answer.sudo(self.user_portal).convert_answer_to_comment()
+            self.answer.with_user(self.user_portal).convert_answer_to_comment()
 
     def test_convert_answer_to_comment(self):
         self.user_portal.karma = KARMA['com_conv_all']
         post_author = self.answer.create_uid.partner_id
-        new_msg = self.answer.sudo(self.user_portal).convert_answer_to_comment()
+        new_msg = self.answer.with_user(self.user_portal).convert_answer_to_comment()
         self.assertEqual(len(new_msg), 1, 'website_forum: wrong answer to comment conversion')
         self.assertEqual(new_msg.author_id, post_author, 'website_forum: wrong answer to comment conversion')
         self.assertIn('I am an anteater', new_msg.body, 'website_forum: wrong answer to comment conversion')
 
     def test_edit_post_crash(self):
         with self.assertRaises(KarmaError):
-            self.post.sudo(self.user_portal).write({'name': 'I am not your father.'})
+            self.post.with_user(self.user_portal).write({'name': 'I am not your father.'})
 
     def test_edit_post(self):
         self.post.create_uid.karma = KARMA['edit_own']
         self.post.write({'name': 'Actually I am your dog.'})
         self.user_portal.karma = KARMA['edit_all']
-        self.post.sudo(self.user_portal).write({'name': 'Actually I am your cat.'})
+        self.post.with_user(self.user_portal).write({'name': 'Actually I am your cat.'})
 
     def test_close_post_crash(self):
         with self.assertRaises(KarmaError):
-            self.post.sudo(self.user_portal).close(None)
+            self.post.with_user(self.user_portal).close(None)
 
     def test_close_post_own(self):
         self.post.create_uid.karma = KARMA['close_own']
@@ -366,11 +366,11 @@ class TestForum(TestForumCommon):
 
     def test_close_post_all(self):
         self.user_portal.karma = KARMA['close_all']
-        self.post.sudo(self.user_portal).close(None)
+        self.post.with_user(self.user_portal).close(None)
 
     def test_deactivate_post_crash(self):
         with self.assertRaises(KarmaError):
-            self.post.sudo(self.user_portal).write({'active': False})
+            self.post.with_user(self.user_portal).write({'active': False})
 
     def test_deactivate_post_own(self):
         self.post.create_uid.karma = KARMA['unlink_own']
@@ -378,11 +378,11 @@ class TestForum(TestForumCommon):
 
     def test_deactivate_post_all(self):
         self.user_portal.karma = KARMA['unlink_all']
-        self.post.sudo(self.user_portal).write({'active': False})
+        self.post.with_user(self.user_portal).write({'active': False})
 
     def test_unlink_post_crash(self):
         with self.assertRaises(KarmaError):
-            self.post.sudo(self.user_portal).unlink()
+            self.post.with_user(self.user_portal).unlink()
 
     def test_unlink_post_own(self):
         self.post.create_uid.karma = KARMA['unlink_own']
@@ -390,4 +390,4 @@ class TestForum(TestForumCommon):
 
     def test_unlink_post_all(self):
         self.user_portal.karma = KARMA['unlink_all']
-        self.post.sudo(self.user_portal).unlink()
+        self.post.with_user(self.user_portal).unlink()