forked from Mapan/odoo17e
123 lines
5.1 KiB
Python
123 lines
5.1 KiB
Python
# -*- coding: utf-8 -*-
|
|
# Part of Odoo. See LICENSE file for full copyright and licensing details.
|
|
|
|
from odoo.addons.knowledge.tests.common import KnowledgeArticlePermissionsCase
|
|
from odoo.tests.common import tagged, users
|
|
from odoo.exceptions import AccessError
|
|
|
|
@tagged('knowledge_comments')
|
|
class TestKnowledgeArticleThreadPermissions(KnowledgeArticlePermissionsCase):
|
|
|
|
@classmethod
|
|
def setUpClass(cls):
|
|
super().setUpClass()
|
|
Threads = cls.env['knowledge.article.thread'].with_context({'mail_create_nolog': True})
|
|
|
|
# Every internal user can write on it
|
|
cls.writable_article = cls.article_roots[0]
|
|
cls.writable_article.invite_members(cls.partner_portal, 'write')
|
|
cls.workspace_thread = Threads.create({
|
|
'article_id': cls.writable_article.id
|
|
})
|
|
cls.workspace_thread.message_post(body='This is a public Thread')
|
|
|
|
# Employee is readonly
|
|
cls.shared_article = cls.article_roots[2]
|
|
cls.shared_thread = Threads.create({
|
|
'article_id': cls.shared_article.id
|
|
})
|
|
cls.shared_thread.message_post(body='This is a shared Thread')
|
|
|
|
# Only employee_manager can write on it
|
|
cls.private_article = cls.env['knowledge.article'].create([
|
|
{'article_member_ids': [
|
|
(0, 0, {'partner_id': cls.partner_employee_manager.id,
|
|
'permission': 'write',
|
|
}),
|
|
],
|
|
'internal_permission': 'none',
|
|
'name': 'Private Root',
|
|
}])
|
|
cls.private_thread = Threads.create({
|
|
'article_id': cls.private_article.id
|
|
})
|
|
cls.private_thread.message_post(body='This is a private Thread')
|
|
|
|
@users('employee')
|
|
def test_create_article_thread_as_employee(self):
|
|
article = self.writable_article.with_env(self.env)
|
|
# writable article
|
|
self.env['knowledge.article.thread'].create([{
|
|
'article_id': article.id,
|
|
}])
|
|
with self.assertRaises(AccessError):
|
|
# readonly article
|
|
self.env['knowledge.article.thread'].create([{
|
|
'article_id': self.shared_article.with_env(self.env).id
|
|
}])
|
|
|
|
@users('employee')
|
|
def test_read_article_thread_as_employee(self):
|
|
private_thread = self.private_thread.with_env(self.env)
|
|
shared_thread = self.shared_thread.with_env(self.env)
|
|
workspace_thread = self.workspace_thread.with_env(self.env)
|
|
|
|
# When you have access to an article you can write and read on threads
|
|
self.assertFalse(workspace_thread.is_resolved)
|
|
self.assertFalse(shared_thread.is_resolved)
|
|
|
|
#* No access to the article = No access to the linked thread
|
|
with self.assertRaises(AccessError):
|
|
private_thread.is_resolved
|
|
|
|
@users('portal_test')
|
|
def test_read_article_thread_as_portal(self):
|
|
private_thread = self.private_thread.with_env(self.env)
|
|
shared_thread = self.shared_thread.with_env(self.env)
|
|
workspace_thread = self.workspace_thread.with_env(self.env)
|
|
|
|
# When you have access to an article you can write and read on threads
|
|
self.assertFalse(workspace_thread.is_resolved)
|
|
with self.assertRaises(AccessError):
|
|
shared_thread.is_resolved
|
|
|
|
#* No access to the article = No access to the linked thread
|
|
with self.assertRaises(AccessError):
|
|
private_thread.is_resolved
|
|
|
|
@users('employee')
|
|
def test_security_thread_resolution(self):
|
|
base_thread = self.private_thread.with_env(self.env)
|
|
|
|
# No access to the article
|
|
with self.assertRaises(AccessError):
|
|
base_thread.toggle_thread()
|
|
|
|
base_thread = self.workspace_thread.with_env(self.env)
|
|
# Access to the article
|
|
self.assertFalse(base_thread.is_resolved)
|
|
base_thread.toggle_thread()
|
|
self.assertTrue(base_thread.is_resolved)
|
|
|
|
@users('portal_test')
|
|
def test_message_post_as_portal(self):
|
|
base_thread = self.private_thread.with_env(self.env)
|
|
with self.assertRaises(AccessError):
|
|
base_thread.message_post(body="It raises an error because of no access")
|
|
|
|
self.private_article.sudo().invite_members(self.partner_portal, 'read')
|
|
|
|
self.assertMembers(self.private_article, 'none', {self.partner_employee_manager: 'write', self.env.user.partner_id: 'read'})
|
|
|
|
message = base_thread.message_post(body="Hello Everyone", partner_ids=[self.partner_employee.id, self.partner_employee_manager.id], tracking_value_ids=[1, 2, 3])
|
|
self.assertEqual(len(base_thread.sudo().message_ids), 2, "Portal user should be able to post a message")
|
|
self.assertListEqual(message.tracking_value_ids.ids, [], "Tracking values should have been filltered")
|
|
|
|
@users('employee')
|
|
def test_message_post_as_employee(self):
|
|
base_thread = self.shared_article.with_env(self.env)
|
|
|
|
self.assertEqual(len(base_thread.message_ids), 1)
|
|
base_thread.message_post(body="Hello Friend")
|
|
self.assertEqual(len(base_thread.message_ids), 2, "A message should have been posted")
|