def test_private_field_not_in_read_group_result(self):
with mock_odoo_request(self.env):
result = self._read_group(self.domain,
self.fields, ['name'],
use_kwargs=True)
assert 'name' in result[0]
assert 'sinid' not in result[0]
def _read_group(self,
domain,
fields,
groupby,
order=None,
use_kwargs=False):
offset = 0
limit = None
with mock_odoo_request(self.env):
if use_kwargs:
args = []
kwargs = {
'domain': domain,
'fields': fields,
'groupby': groupby,
'orderby': order,
'limit': limit,
'offset': offset,
}
else:
args = [domain, fields, groupby, limit, offset, order]
kwargs = {}
return self.controller.call_kw('hr.employee', 'read_group', args,
kwargs)
def _search_read(self,
domain,
fields,
use_search_read_route=False,
use_kwargs=False,
order=None):
offset = 0
limit = None
with mock_odoo_request(self.env):
if use_search_read_route:
result = self.controller.search_read('hr.employee',
domain=domain,
fields=fields,
sort=order,
offset=offset,
limit=limit)
return result['records']
elif use_kwargs:
self.controller.call_kw(
'hr.employee', 'search_read', [], {
'domain': domain,
'fields': fields,
'offset': offset,
'limit': limit,
'order': order,
})
else:
return self.controller.call(
'hr.employee', 'search_read',
[domain, fields, offset, limit, order])
def _read_group(self,
domain,
fields,
groupby,
order=None,
use_kwargs=False):
offset = 0
limit = None
with mock_odoo_request(self.env):
if use_kwargs:
args = []
kwargs = {
"domain": domain,
"fields": fields,
"groupby": groupby,
"orderby": order,
"limit": limit,
"offset": offset,
}
else:
args = [domain, fields, groupby, limit, offset, order]
kwargs = {}
return self.controller.call_kw("hr.employee", "read_group", args,
kwargs)
def test_private_field_removed_from_search_result(self,
use_search_read_route):
with mock_odoo_request(self.env):
result = self._search_read(self.domain, self.fields,
use_search_read_route)
assert 'name' in result[0]
assert 'sinid' not in result[0]
def test_if_private_field_used_to_group__raise_error(
self, use_kwargs, groupby):
with mock_odoo_request(self.env):
with pytest.raises(AccessError):
self._read_group(self.domain,
self.fields,
groupby,
use_kwargs=use_kwargs)
def test_if_private_field_used_to_order_search_read__raise_error(
self, use_search_read_route, use_kwargs):
with mock_odoo_request(self.env):
with pytest.raises(AccessError):
self._search_read(self.domain,
self.fields,
use_search_read_route,
use_kwargs,
order='sinid')
def _update_cart(self):
with mock_odoo_request(self.env):
request.session.update({
'sale_order_id': self.sale_order.id,
})
self.sale_order._cart_update(self.product.id,
self.line_1.id,
add_qty=0,
set_qty=0)
def _read_grid(self, domain):
with mock_odoo_request(self.env):
args = []
kwargs = {
"row_fields": [],
"col_field": "industry_id",
"cell_field": "industry_id",
"domain": domain,
}
return self.controller.call_kw("res.partner", "read_grid", args,
kwargs)
def _read_grid(self, domain):
with mock_odoo_request(self.env):
args = []
kwargs = {
'row_fields': ['company_id'],
'col_field': 'company_id',
'cell_field': 'company_id',
'domain': domain,
}
return self.controller.call_kw('res.partner', 'read_grid', args,
kwargs)
def _search_read(self, domain, use_search_read_route, domain_kwarg):
with mock_odoo_request(self.env):
if use_search_read_route:
result = self.controller.search_read('res.partner', fields=[], domain=domain)
records = result['records']
elif domain_kwarg:
records = self.controller.call('res.partner', 'search_read', [domain, []])
else:
records = self.controller.call_kw(
'res.partner', 'search_read', [], {'domain': domain})
return [r['id'] for r in records]
def _read_group(self, domain, fields, groupby, domain_kwarg):
with mock_odoo_request(self.env):
if domain_kwarg:
args = []
kwargs = {
'domain': domain, 'fields': fields,
'groupby': groupby, 'orderby': groupby
}
else:
args = [domain, [], fields, groupby]
kwargs = {'orderby': groupby}
return self.controller.call_kw('res.partner', 'read_group', args, kwargs)
def _export(self, ids, domain, fields, model='hr.employee'):
params = {
'model': model,
'ids': ids,
'domain': domain,
'import_compat': True,
'fields': fields,
}
data_ = json.dumps(params)
token = 'test1234'
with mock_odoo_request(self.env):
response = self.controller.base(data_, token)
return response.data.decode('utf-8')
def _export(self, ids, domain):
params = {
'model': 'res.partner',
'ids': ids,
'domain': domain,
'import_compat': True,
'fields': [{'name': 'name'}],
}
data_ = json.dumps(params)
token = 'test1234'
with mock_odoo_request(self.env):
response = self.controller.base(data_, token)
return response.data.decode('utf-8')
def _name_search(self, name, domain, name_kwarg, domain_kwarg):
with mock_odoo_request(self.env):
args = []
kwargs = {}
if name_kwarg:
kwargs['name'] = name
else:
args.append(name)
if domain_kwarg:
kwargs['args'] = domain
else:
args.append(domain)
name_get = self.controller.call_kw('res.partner', 'name_search', args, kwargs)
return [r[0] for r in name_get]
def _search(self,
domain,
use_kwargs=False,
order=None,
model='hr.employee'):
offset = 0
limit = None
with mock_odoo_request(self.env):
if use_kwargs:
self.controller.call_kw(
model, 'search', [], {
'domain': domain,
'offset': offset,
'limit': limit,
'order': order,
})
else:
return self.controller.call(model, 'search',
[domain, offset, limit, order])
def _search(self,
domain,
use_kwargs=False,
order=None,
model="hr.employee"):
offset = 0
limit = None
with mock_odoo_request(self.env):
if use_kwargs:
self.controller.call_kw(
model,
"search",
[],
{
"domain": domain,
"offset": offset,
"limit": limit,
"order": order,
},
)
else:
return self.controller.call(model, "search",
[domain, offset, limit, order])
def _search_read(self,
domain,
fields,
use_search_read_route=False,
use_kwargs=False,
order=None):
offset = 0
limit = None
with mock_odoo_request(self.env):
if use_search_read_route:
result = self.controller.search_read(
"hr.employee",
domain=domain,
fields=fields,
sort=order,
offset=offset,
limit=limit,
)
return result["records"]
elif use_kwargs:
self.controller.call_kw(
"hr.employee",
"search_read",
[],
{
"domain": domain,
"fields": fields,
"offset": offset,
"limit": limit,
"order": order,
},
)
else:
return self.controller.call(
"hr.employee", "search_read",
[domain, fields, offset, limit, order])
def test_employee_access_post(self):
with mock_odoo_request(self.env(user=self.employee)):
WebsiteBlogInternal().blog_post(
blog=self.blog, blog_post=self.env["blog.post"].search([], limit=1)
)
def test_if_private_field_used_in_search_read_domain__raise_error(
self, use_search_read_route):
with mock_odoo_request(self.env):
with pytest.raises(AccessError):
self._search_read([('sinid', '!=', False)], self.fields,
use_search_read_route)
def _read(self, records):
with mock_odoo_request(self.env):
return self.controller.call(
'res.partner', 'read',
[records.ids, ['name', 'customer', 'supplier']]
)
def test_private_field_removed_from_read_request(self):
with mock_odoo_request(self.env):
result = self.controller.call('hr.employee', 'read',
[self.employee.ids, self.fields])
assert 'name' in result[0]
assert 'sinid' not in result[0]
def test_if_search_with_invalid_domain__raise_validation_error(self):
domain = [('wrong_relation_field.sinid', '>', '123')]
with mock_odoo_request(self.env):
with pytest.raises(ValidationError):
self._search(domain, model='res.users')
def test_if_search_by_related_model__domain_checked_for_private_field(
self):
domain = [('employee_ids.sinid', '>', '123')]
with mock_odoo_request(self.env):
with pytest.raises(AccessError):
self._search(domain, model='res.users')
def _write(self, records, values):
with mock_odoo_request(self.env):
return self.controller.call('res.partner', 'write', [records.ids, values])
def _create(self, values):
with mock_odoo_request(self.env):
return self.controller.call('res.partner', 'create', [values])
def _unlink(self, records):
with mock_odoo_request(self.env):
return self.controller.call('res.partner', 'unlink', [records.ids])
def test_employee_access_feed(self):
with mock_odoo_request(self.env(user=self.employee)):
WebsiteBlogInternal().blog_feed(blog=self.blog)
def test_customer_access_post(self):
with mock_odoo_request(self.env(user=self.customer)), pytest.raises(NotFound):
WebsiteBlogInternal().blog_post(
blog=self.blog, blog_post=self.env["blog.post"].search([], limit=1)
)
def test_customer_access_feed(self):
with mock_odoo_request(self.env(user=self.customer)), pytest.raises(NotFound):
WebsiteBlogInternal().blog_feed(blog=self.blog)
