230 lines
9.4 KiB
Python
230 lines
9.4 KiB
Python
# -*- coding: utf-8 -*-
|
|
|
|
from odoo.exceptions import UserError, AccessError
|
|
from odoo.tests import common
|
|
from odoo.tools import frozendict
|
|
from odoo import Command
|
|
|
|
|
|
class TestCompanyCheck(common.TransactionCase):
|
|
|
|
def setUp(self):
|
|
super(TestCompanyCheck, self).setUp()
|
|
self.company_a = self.env['res.company'].create({
|
|
'name': 'Company A'
|
|
})
|
|
self.company_b = self.env['res.company'].create({
|
|
'name': 'Company B'
|
|
})
|
|
self.parent_company_a_id = self.env['test_new_api.model_parent'].create({
|
|
'name': 'M1',
|
|
'company_id': self.company_a.id,
|
|
})
|
|
self.parent_company_b_id = self.env['test_new_api.model_parent'].create({
|
|
'name': 'M2',
|
|
'company_id': self.company_b.id,
|
|
})
|
|
self.company_c = self.env['res.company'].create({
|
|
'name': 'Company C'
|
|
})
|
|
|
|
self.test_user = self.env['res.users'].create({
|
|
'name': 'Test',
|
|
'login': 'test',
|
|
'company_id': self.company_a.id,
|
|
'company_ids': (self.company_a | self.company_c).ids,
|
|
})
|
|
|
|
def test_company_check_0(self):
|
|
""" Check the option _check_company_auto is well set on records"""
|
|
m1 = self.env['test_new_api.model_child'].create({'company_id': self.company_a.id})
|
|
self.assertTrue(m1._check_company_auto)
|
|
|
|
def test_company_check_1(self):
|
|
""" Check you can create an object if the company are consistent"""
|
|
self.env['test_new_api.model_child'].create({
|
|
'name': 'M1',
|
|
'company_id': self.company_a.id,
|
|
'parent_id': self.parent_company_a_id.id,
|
|
})
|
|
|
|
def test_company_check_2(self):
|
|
""" Check you cannot create a record if the company is inconsistent"""
|
|
with self.assertRaises(UserError):
|
|
self.env['test_new_api.model_child'].create({
|
|
'name': 'M1',
|
|
'company_id': self.company_b.id,
|
|
'parent_id': self.parent_company_a_id.id,
|
|
})
|
|
|
|
def test_company_check_3(self):
|
|
""" Check you can create a record with the inconsistent company if there are no check"""
|
|
self.env['test_new_api.model_child_nocheck'].create({
|
|
'name': 'M1',
|
|
'company_id': self.company_b.id,
|
|
'parent_id': self.parent_company_a_id.id,
|
|
})
|
|
|
|
def test_company_check_4(self):
|
|
""" Check the company consistency is respected at write. """
|
|
child = self.env['test_new_api.model_child'].create({
|
|
'name': 'M1',
|
|
'company_id': self.company_a.id,
|
|
'parent_id': self.parent_company_a_id.id,
|
|
})
|
|
|
|
with self.assertRaises(UserError):
|
|
child.company_id = self.company_b.id
|
|
|
|
with self.assertRaises(UserError):
|
|
child.parent_id = self.parent_company_b_id.id
|
|
|
|
child.write({
|
|
'parent_id': self.parent_company_b_id.id,
|
|
'company_id': self.company_b.id,
|
|
})
|
|
|
|
def test_company_environment(self):
|
|
""" Check the company context on the environment is verified. """
|
|
|
|
user = self.test_user.with_user(self.test_user).with_context(allowed_company_ids=[])
|
|
|
|
# When accessing company/companies, check raises error if unauthorized/unexisting company.
|
|
with self.assertRaises(AccessError):
|
|
user.with_context(allowed_company_ids=[self.company_a.id, self.company_b.id, self.company_c.id]).env.companies
|
|
|
|
with self.assertRaises(AccessError):
|
|
user.with_context(allowed_company_ids=[self.company_b.id]).env.company
|
|
|
|
with self.assertRaises(AccessError):
|
|
# crap in company context is not allowed.
|
|
user.with_context(allowed_company_ids=['company_qsdf', 'company564654']).env.companies
|
|
|
|
# In sudo mode, context check is bypassed.
|
|
companies = (self.company_a | self.company_b)
|
|
self.assertEqual(
|
|
user.sudo().with_context(allowed_company_ids=companies.ids).env.companies,
|
|
companies
|
|
)
|
|
|
|
self.assertEqual(
|
|
user.sudo().with_context(
|
|
allowed_company_ids=[self.company_b.id, 'abc']).env.company,
|
|
self.company_b
|
|
)
|
|
"""
|
|
wrong_env = user.sudo().with_context(
|
|
allowed_company_ids=[self.company_a.id, self.company_b.id, 'abc'])
|
|
wrong_env.env.companies.mapped('name')
|
|
# Wrong SQL query due to wrong company id.
|
|
"""
|
|
# Fallbacks when no allowed_company_ids context key
|
|
self.assertEqual(user.env.company, user.company_id)
|
|
self.assertEqual(user.env.companies, user.company_ids)
|
|
|
|
def test_with_company(self):
|
|
""" Check that with_company() works as expected """
|
|
|
|
user = self.test_user.with_user(self.test_user).with_context(allowed_company_ids=[])
|
|
self.assertEqual(user.env.companies, user.company_ids)
|
|
|
|
self.assertEqual(user.with_company(user.env.company).env.company, user.env.company)
|
|
self.assertEqual(
|
|
user.with_company(self.company_a).env.company,
|
|
user.with_company(self.company_a.id).env.company
|
|
)
|
|
|
|
# Falsy values shouldn't change current environment, record, or context.
|
|
for falsy in [False, None, 0, '', self.env['res.company'], []]:
|
|
no_change = user.with_company(falsy)
|
|
self.assertEqual(no_change, user)
|
|
self.assertEqual(no_change.env.context, user.env.context)
|
|
self.assertEqual(no_change.env, user.env)
|
|
|
|
comp_a_user = user.with_company(user.company_id)
|
|
comp_a_user2 = user.with_context(allowed_company_ids=user.company_id.ids)
|
|
|
|
# Using with_company(c) or with_context(allowed_company_ids=[c])
|
|
# should return the same context
|
|
# and the same environment (reused if no changes)
|
|
self.assertEqual(comp_a_user.env, comp_a_user2.env)
|
|
self.assertEqual(comp_a_user.env.context, comp_a_user2.env.context)
|
|
|
|
# When there were no company in the context, using with_company
|
|
# restricts both env.company and env.companies.
|
|
self.assertEqual(comp_a_user.env.company, user.company_id)
|
|
self.assertEqual(comp_a_user.env.companies, user.company_id)
|
|
|
|
# Reordering allowed_company_ids ctxt key
|
|
# Ensure with_company reorders the context key content
|
|
# and by consequent changes env.company
|
|
comp_c_a_user = comp_a_user.with_company(self.company_c)
|
|
self.assertEqual(comp_c_a_user.env.company, self.company_c)
|
|
self.assertEqual(comp_c_a_user.env.companies, self.company_c + self.company_a)
|
|
self.assertEqual(comp_c_a_user.env.companies[0], self.company_c)
|
|
self.assertEqual(comp_c_a_user.env.companies[1], self.company_a)
|
|
self.assertEqual(
|
|
comp_c_a_user.env.context['allowed_company_ids'],
|
|
[self.company_c.id, self.company_a.id],
|
|
)
|
|
|
|
comp_a_c_user = comp_c_a_user.with_company(self.company_a)
|
|
self.assertEqual(comp_a_c_user.env.companies[0], self.company_a)
|
|
self.assertEqual(comp_a_c_user.env.companies[1], self.company_c)
|
|
self.assertEqual(
|
|
comp_a_c_user.env.context['allowed_company_ids'],
|
|
[self.company_a.id, self.company_c.id],
|
|
)
|
|
|
|
# Special case: _flush() can create a context with allowed_company_ids
|
|
# being None; it should be interpreted as [].
|
|
none_user = user.with_context(allowed_company_ids=None)
|
|
self.assertEqual(none_user.env.company, user.company_id)
|
|
self.assertEqual(none_user.env.companies, user.company_ids)
|
|
|
|
comp_user = none_user.with_company(user.company_id)
|
|
self.assertEqual(comp_user.env.company, user.company_id)
|
|
self.assertEqual(comp_user.env.companies, user.company_id)
|
|
|
|
def test_company_check_no_access(self):
|
|
""" Test that company_check validates correctly the companies on
|
|
the different records, even if the use has no access to one of the
|
|
records, example, a private address set by an onchange
|
|
"""
|
|
|
|
user = self.env['res.users'].create({
|
|
'name': 'My Classic User',
|
|
'login': 'My Classic User',
|
|
'groups_id': [Command.set(self.env.ref('base.group_user').ids)],
|
|
})
|
|
|
|
with common.Form(self.env['test_new_api.model_private_address_onchange'].with_user(user)) as form:
|
|
form.name = 'My Classic Name'
|
|
form.company_id = self.env.user.company_id
|
|
with self.assertRaises(AccessError):
|
|
form.address_id.name
|
|
form.save()
|
|
|
|
def test_company_sticky_with_context(self):
|
|
context = frozendict({'nothing_to_see_here': True})
|
|
companies_1 = frozendict({'allowed_company_ids': [1]})
|
|
companies_2 = frozendict({'allowed_company_ids': [2]})
|
|
|
|
User = self.env['res.users'].with_context(context)
|
|
self.assertEqual(User.env.context, context)
|
|
|
|
User = User.with_context(**companies_1)
|
|
self.assertEqual(User.env.context, dict(context, **companies_1))
|
|
|
|
# 'allowed_company_ids' is replaced if present in keys
|
|
User = User.with_context(**companies_2)
|
|
self.assertEqual(User.env.context, dict(context, **companies_2))
|
|
|
|
# 'allowed_company_ids' is replaced if present in new context
|
|
User = User.with_context(companies_1)
|
|
self.assertEqual(User.env.context, companies_1)
|
|
|
|
# 'allowed_company_ids' is sticky
|
|
User = User.with_context(context)
|
|
self.assertEqual(User.env.context, dict(context, **companies_1))
|