def setUpClass(cls):
super().setUpClass()
cls.simple_user = new_test_user(cls.env,
'smp',
groups='base.group_user',
name='Simple User',
email='*****@*****.**')
cls.interviewer_user = new_test_user(
cls.env,
'itw',
groups=
'base.group_user,hr_recruitment.group_hr_recruitment_interviewer',
name='Recruitment Interviewer',
email='*****@*****.**')
cls.manager_user = new_test_user(
cls.env,
'mng',
groups=
'base.group_user,hr_recruitment.group_hr_recruitment_manager',
name='Recruitment Manager',
email='*****@*****.**')
cls.job = cls.env['hr.job'].create({
'name': 'super nice job',
'user_id': cls.manager_user.id,
})
def setUp(self):
super().setUp()
self.manager_user = new_test_user(self.env, login='******')
self.manager = self.env['hr.employee'].create({
'name':
'Manager Tiranique',
'user_id':
self.manager_user.id,
})
self.employee_user = new_test_user(self.env, login='******')
self.employee = self.env['hr.employee'].create({
'name':
"Michaël Hawkins",
'parent_id':
self.manager.id,
'work_email':
'*****@*****.**',
'user_id':
self.employee_user.id,
'address_home_id':
self.env['res.partner'].create({
'name': 'Private contact',
'email': '*****@*****.**'
}).id,
})
self.employee.work_email = '*****@*****.**'
def test_change_login(self):
new_test_user(self.env, login='******', website_id=self.website_1.id)
user_belle = new_test_user(self.env,
login='******',
website_id=self.website_1.id)
with self.assertRaises(IntegrityError), mute_logger('odoo.sql_db'):
user_belle.login = '******'
def test_orphan(self):
""" What happens with orphan translations. """
self.env['res.lang']._activate_lang('fr_FR')
# create a user with access rights on partner categories
user = new_test_user(self.env, 'deleter')
group = self.env.ref('base.group_partner_manager')
user.groups_id = [(4, group.id)]
# this access rule triggers a MissingError
self.env['ir.rule'].create({
'model_id':
self.env['ir.model']._get_id('res.partner.category'),
'groups': [(4, group.id)],
'domain_force':
"[('name', 'ilike', 'e')]",
})
# create a translation, and delete the record from the database
translation = self.env['ir.translation'].create({
'type':
'model',
'name':
'res.partner.category,name',
'lang':
'fr_FR',
'res_id':
self.category.id,
'src':
'Reblochon',
'value':
'Parfum Exquis',
'state':
'translated',
})
translation.flush()
translation.invalidate_cache()
self.cr.execute("DELETE FROM res_partner_category WHERE id=%s",
[self.category.id])
# deleting the translation should be possible, provided the user has
# access rights on the translation's model
user0 = new_test_user(self.env, 'cannot modify category')
with self.assertRaises(AccessError):
translation.with_user(user0).unlink()
translation.with_user(user).unlink()
# however, creating orphan translations should not be possible
with self.assertRaises(ValidationError):
translation.with_user(user).create({
'type': 'model',
'name': 'res.partner.category,name',
'lang': 'fr_FR',
'res_id': self.category.id,
'src': 'Reblochon',
'value': 'Parfum Exquis',
'state': 'translated',
})
def test_greeting2_headers_db(self):
new_test_user(self.env, 'jackoneill', context={'lang': 'en_US'})
self.authenticate('jackoneill', 'jackoneill')
res = self.db_url_open('/test_http/greeting')
self.assertEqual(res.status_code, 200)
self.assertEqual(res.headers.get('Content-Type'),
'text/html; charset=utf-8')
self.assertEqual(res.text, "Tek'ma'te")
def setUp(self):
super().setUp()
self.task = self.create_task('Make the world a better place')
self.user = new_test_user(self.env,
'Internal user',
groups='base.group_user')
self.portal = new_test_user(self.env,
'Portal user',
groups='base.group_portal')
def test_websites_set_null(self):
user_1 = new_test_user(self.env,
login='******',
website_id=self.website_1.id)
user_2 = new_test_user(self.env,
login='******',
website_id=self.website_2.id)
with self.assertRaises(ValidationError):
(user_1 | user_2).write({'website_id': False})
def setUpClass(cls):
super().setUpClass()
cls.john = new_test_user(cls.env,
login='******',
groups='base.group_user')
cls.raoul = new_test_user(cls.env,
login='******',
groups='base.group_user')
cls.portal = new_test_user(cls.env,
login='******',
groups='base.group_portal')
def test_web_login(self):
new_test_user(self.env, 'jackoneill', context={'lang': 'en_US'})
res_post = self.login('jackoneill', 'jackoneill')
# ensure we are logged-in
self.url_open(
'/web/session/check',
headers={'Content-Type': 'application/json'},
data='{}'
).raise_for_status()
# ensure we end up on the right page for internal users.
self.assertEqual(res_post.request.path_url, '/web')
def test_same_website_message(self):
@check # Check decorator, otherwise translation is not applied
def check_new_test_user(dbname):
new_test_user(self.env(context={'land': 'en_US'}),
login='******',
website_id=self.website_1.id)
new_test_user(self.env, login='******', website_id=self.website_1.id)
# Should be a ValidationError (with a nice translated error message),
# not an IntegrityError
with self.assertRaises(ValidationError), mute_logger('odoo.sql_db'):
check_new_test_user(self.env.registry._db.dbname)
def test_multicompany(self):
""" Test value is not reused from cache when allowed_company_ids changes """
be = self.env.ref('base.be')
fr = self.env.ref('base.fr')
company_1 = self.env['res.company'].create({'name': 'Table', 'country_id': be.id})
company_2 = self.env['res.company'].create({'name': 'Tableau', 'country_id': fr.id})
user = new_test_user(self.env, login='******', groups='hr.group_hr_user',
company_id=company_2.id,
company_ids=[(6, 0, (company_1 + company_2).ids)])
rule_parameter = self.env['hr.rule.parameter'].create({
'name': 'Test Parameter',
'code': 'test_parameter',
'country_id': be.id,
})
self.env['hr.rule.parameter.value'].create({
'rule_parameter_id': rule_parameter.id,
'date_from': date(2015, 10, 10),
'parameter_value': 100,
})
with self.assertRaises(UserError):
# Read a BE parameter from FR company
self.env['hr.rule.parameter'].with_user(user).with_company(company_2)._get_parameter_from_code('test_parameter')
# Read a BE parameter from BE company, value is set in cache
be_value = self.env['hr.rule.parameter'].with_user(user).with_company(company_1)._get_parameter_from_code('test_parameter')
self.assertEqual(be_value, 100)
with self.assertRaises(UserError):
# Read a BE parameter from FR company
# Value should not come from cache, access rights should be checked
self.env['hr.rule.parameter'].with_user(user).with_company(company_2)._get_parameter_from_code('test_parameter')
def setUpClass(cls):
super().setUpClass()
cls.partner = cls.env['res.partner'].create({'name': "Mur en béton"})
sale_order = cls.env['sale.order'].with_context(
tracking_disable=True).create({
'partner_id':
cls.partner.id,
'partner_invoice_id':
cls.partner.id,
'partner_shipping_id':
cls.partner.id,
})
product = cls.env['product.product'].create({
'name': "Prepaid Consulting",
'type': 'service',
})
cls.order_line = cls.env['sale.order.line'].create({
'name':
"Order line",
'product_id':
product.id,
'order_id':
sale_order.id,
})
cls.user = new_test_user(cls.env, login='******')
def test_attendee_removed(self):
user = new_test_user(self.env, login='******')
google_id = 'oj44nep1ldf8a3ll02uip0c9aa'
event = self.env['calendar.event'].with_user(user).create({
'name': 'coucou',
'start': date(2020, 1, 6),
'stop': date(2020, 1, 6),
'google_id': google_id,
'user_id': False, # user is not owner
'partner_ids': [(6, 0, user.partner_id.ids)], # but user is attendee
})
gevent = GoogleEvent([{
'id': google_id,
'description': 'Small mini desc',
"updated": self.now,
'organizer': {'email': '*****@*****.**', 'self': True},
'summary': 'Pricing new update',
'visibility': 'public',
'attendees': [], # <= attendee removed in Google
'reminders': {'useDefault': True},
'start': {
'dateTime': '2020-01-13T16:55:00+01:00',
'timeZone': 'Europe/Brussels'
},
'end': {
'dateTime': '2020-01-13T19:55:00+01:00',
'timeZone': 'Europe/Brussels'
},
}])
self.assertEqual(event.partner_ids, user.partner_id)
self.assertEqual(event.attendee_ids.partner_id, user.partner_id)
self.sync(gevent)
# User attendee removed but gevent owner might be added after synch.
self.assertNotEqual(event.attendee_ids.partner_id, user.partner_id)
self.assertNotEqual(event.partner_ids, user.partner_id)
def test_spreadsheet_to_display_without_contrib(self):
user = new_test_user(self.env,
login="******",
groups="documents.group_documents_user")
with freeze_time('2020-02-02 18:00'):
spreadsheet1 = self.env["documents.document"].with_user(
user).create({
"raw": r"{}",
"folder_id": self.folder.id,
"handler": "spreadsheet",
"mimetype": "application/o-spreadsheet",
})
with freeze_time('2020-02-15 18:00'):
spreadsheet2 = self.env["documents.document"].create({
"raw":
r"{}",
"folder_id":
self.folder.id,
"handler":
"spreadsheet",
"mimetype":
"application/o-spreadsheet",
})
spreadsheets = self.env["documents.document"].with_user(
user).get_spreadsheets_to_display()
spreadsheet_ids = [s["id"] for s in spreadsheets]
self.assertEqual(spreadsheet_ids, [spreadsheet1.id, spreadsheet2.id])
def test_planning_default_times_timezoned(self):
""" User with timezone A creates a slot for employee in timezone B """
employee = self.env['hr.employee'].create({
'name': "John",
'tz': 'Europe/Brussels',
})
user = new_test_user(self.env,
"Johnny Testing",
tz='Asia/Colombo',
groups='planning.group_planning_manager')
start, end = datetime(2020, 1, 1, 8, 0), datetime(2020, 1, 11, 18, 0)
context = dict(
default_employee_id=employee.id,
default_start_datetime=start,
default_end_datetime=end,
)
with Form(self.env['planning.slot'].with_user(user).with_context(
context)) as slot:
# until we find a proper way to do it:
self.assertEqual(
slot.start_datetime, start,
"It should not have been adjusted to the employee's calendar")
self.assertEqual(
slot.end_datetime, end,
"It should not have been adjusted to the employee's calendar")
def test_attendees_same_event_both_share(self):
google_id = 'oj44nep1ldf8a3ll02uip0c9aa'
other_user = new_test_user(self.env, login='******')
event = self.env['calendar.event'].create({
'name': 'coucou',
'start': date(2020, 1, 6),
'stop': date(2020, 1, 6),
'allday': True,
'google_id': google_id,
'need_sync': False,
'user_id': other_user.id, # Not the current user
'partner_ids': [(6, 0, [self.env.user.partner_id.id, other_user.partner_id.id], )] # current user is attendee
})
event.write({'start': date(2020, 1, 7), 'stop': date(2020, 1, 8)})
# To avoid 403 errors, we send a limited dictionnary when we don't have write access.
# guestsCanModify property is not properly handled yet
self.assertGoogleEventPatched(event.google_id, {
'id': event.google_id,
'start': {'date': str(event.start_date)},
'end': {'date': str(event.stop_date + relativedelta(days=1))},
'summary': 'coucou',
'description': '',
'location': '',
'guestsCanModify': True,
'organizer': {'email': '*****@*****.**', 'self': False},
'attendees': [{'email': '*****@*****.**', 'responseStatus': 'needsAction'},
{'email': '*****@*****.**', 'responseStatus': 'accepted'},],
'extendedProperties': {'shared': {'%s_odoo_id' % self.env.cr.dbname: event.id,
'%s_owner_id' % self.env.cr.dbname: other_user.id}},
'reminders': {'overrides': [], 'useDefault': False},
'visibility': 'public',
}, timeout=3)
def setUpClass(cls):
super().setUpClass()
cls.company_a = cls.env['res.company'].create({'name': "A"})
cls.company_b = cls.env['res.company'].create({'name': "B"})
cls.company_c = cls.env['res.company'].create({'name': "C"})
cls.companies = [cls.company_a, cls.company_b, cls.company_c]
cls.user_password = "******"
cls.user = common.new_test_user(cls.env,
"session",
email="*****@*****.**",
password=cls.user_password,
tz="UTC")
cls.user.write({
'company_id':
cls.company_a.id,
'company_ids':
[Command.set([company.id for company in cls.companies])],
})
cls.payload = json.dumps(
dict(jsonrpc="2.0", method="call", id=str(uuid4())))
cls.headers = {
"Content-Type": "application/json",
}
def test_attendee_cancelled(self):
""" Cancel event when the current user is not the organizer """
user = new_test_user(self.env, login='******')
google_id = 'oj44nep1ldf8a3ll02uip0c9aa'
event = self.env['calendar.event'].create({
'name':
'coucou',
'start':
date(2020, 1, 5),
'stop':
date(2020, 1, 6),
'allday':
True,
'google_id':
google_id,
'need_sync':
False,
'user_id':
False, # Not the current user
'partner_ids': [Command.set(user.partner_id.ids)],
})
gevent = GoogleEvent([{
'id': google_id,
'status': 'cancelled',
}])
user_attendee = event.attendee_ids
self.assertEqual(user_attendee.state, 'needsAction')
# We have to call sync with the attendee user
gevent.clear_type_ambiguity(self.env)
self.env['calendar.event'].with_user(user)._sync_google2odoo(gevent)
self.assertTrue(event.active)
user_attendee = event.attendee_ids
self.assertTrue(user_attendee)
self.assertEqual(user_attendee.state, 'declined')
self.assertGoogleAPINotCalled()
def test_project_specific_permission(self):
self.project_pigs.allowed_user_ids = self.user
john = new_test_user(self.env, 'John')
self.task.allowed_user_ids |= john
self.project_pigs.allowed_user_ids -= self.user
self.assertIn(john, self.task.allowed_user_ids,
"John should still be allowed to read the task")
def test_valid_owner_property(self):
user = new_test_user(self.env, login='******')
values = {
'id': 'oj44nep1ldf8a3ll02uip0c9aa',
'description': 'Small mini desc',
'organizer': {
'email': '*****@*****.**',
'self': True
},
'summary': 'Pricing new update',
'visibility': 'public',
'attendees': [],
'reminders': {
'useDefault': True
},
'start': {
'dateTime': '2020-01-13T16:55:00+01:00',
'timeZone': 'Europe/Brussels'
},
'extendedProperties': {
'shared': {
'%s_owner_id' % self.env.cr.dbname: str(user.id)
}
},
'end': {
'dateTime': '2020-01-13T19:55:00+01:00',
'timeZone': 'Europe/Brussels'
},
}
self.env['calendar.event']._sync_google2odoo(GoogleEvent([values]))
event = self.env['calendar.event'].search([('google_id', '=',
values.get('id'))])
self.assertEqual(event.user_id, user)
self.assertGoogleAPINotCalled()
def test_user_no_access(self):
user = new_test_user(self.env,
login='******',
groups='base.group_user')
with self.with_user('noProfile'), self.assertRaises(AccessError):
self.env['ir.profile'].search([])
with self.assertRaises(AccessError):
self.test_profile.with_user(user).read(['name'])
def setUp(self):
super().setUp()
self.user = new_test_user(self.env, "test_user_1", email="*****@*****.**", tz="UTC")
self.other_user = new_test_user(self.env, "test_user_2", email="*****@*****.**", password="******", tz="UTC")
self.partner = self.user.partner_id
self.event = (
self.env["calendar.event"]
.create(
{
"name": "Doom's day",
"start": datetime(2019, 10, 25, 8, 0),
"stop": datetime(2019, 10, 27, 18, 0),
"partner_ids": [(4, self.partner.id)],
}
)
.with_context(mail_notrack=True)
)
def test_attendee_state(self):
user = new_test_user(self.env, login='******')
google_id = 'oj44nep1ldf8a3ll02uip0c9aa'
event = self.env['calendar.event'].with_user(user).create({
'name':
'Event with me',
'start':
date(2020, 1, 6),
'stop':
date(2020, 1, 6),
'google_id':
google_id,
'user_id':
False, # user is not owner
'need_sync':
False,
'partner_ids':
[(6, 0, user.partner_id.ids)], # but user is attendee
})
self.assertEqual(event.attendee_ids.state, 'accepted')
# The event is declined from Google
values = {
'id':
google_id,
'description':
'Changed my mind',
"updated":
self.now,
'organizer': {
'email': '*****@*****.**',
'self': True
},
'summary':
"""I don't want to be with me anymore""",
'visibility':
'public',
'attendees': [
{
'displayName': 'calendar-user (base.group_user)',
'email': '*****@*****.**',
'responseStatus': 'declined'
},
],
'reminders': {
'useDefault': True
},
'start': {
'dateTime': '2020-01-13T16:55:00+01:00',
'timeZone': 'Europe/Brussels'
},
'end': {
'dateTime': '2020-01-13T19:55:00+01:00',
'timeZone': 'Europe/Brussels'
},
}
self.env['calendar.event']._sync_google2odoo(GoogleEvent([values]))
self.assertEqual(event.attendee_ids.state, 'declined')
self.assertGoogleAPINotCalled()
def setUp(self):
super(TestCommitStatus, self).setUp()
self.project = self.env['runbot.project'].create({'name': 'Tests'})
self.repo_server = self.env['runbot.repo'].create({
'name': 'server',
'project_id': self.project.id,
'server_files': 'server.py',
'addons_paths': 'addons,core/addons'
})
self.server_commit = self.env['runbot.commit'].create({
'name': 'dfdfcfcf0000ffffffffffffffffffffffffffff',
'repo_id': self.repo_server.id
})
create_context = {'no_reset_password': True, 'mail_create_nolog': True, 'mail_create_nosubscribe': True, 'mail_notrack': True}
self.simple_user = new_test_user(self.env, login='******', name='simple', password='******', context=create_context)
self.runbot_admin = new_test_user(self.env, groups='runbot.group_runbot_admin,base.group_user', login='******', name='runbot_admin', password='******', context=create_context)
def test_spreadsheet_to_display_access_portal(self):
portal = new_test_user(self.env,
"Test user",
groups='base.group_portal')
with self.assertRaises(
AccessError,
msg="A portal user should not be able to read spreadsheet"):
self.env["documents.document"].with_user(
portal).get_spreadsheets_to_display()
def setUpClass(cls):
super().setUpClass()
cls.event = cls.env['calendar.event'].create({
'name': "Doom's day",
'start': datetime(2019, 10, 25, 8, 0),
'stop': datetime(2019, 10, 27, 18, 0),
}).with_context(mail_notrack=True)
cls.user = new_test_user(cls.env, 'xav', email='*****@*****.**', notification_type='inbox')
cls.partner = cls.user.partner_id
def test_project_specific_remove_mutliple_tasks(self):
self.project_pigs.allowed_user_ids = self.user
john = new_test_user(self.env, 'John')
task = self.create_task('task')
self.task.allowed_user_ids |= john
self.project_pigs.allowed_user_ids -= self.user
self.assertIn(john, self.task.allowed_user_ids)
self.assertNotIn(john, task.allowed_user_ids)
self.assertNotIn(self.user, task.allowed_user_ids)
self.assertNotIn(self.user, self.task.allowed_user_ids)
def test_greeting0_matrix(self):
new_test_user(self.env, 'jackoneill', context={'lang': 'en_US'})
test_matrix = [
# path, database, login, expected_code, expected_re_pattern
('/test_http/greeting', False, None, 200, r"Tek'ma'te"),
('/test_http/greeting', True, None, 200, r"Tek'ma'te"),
('/test_http/greeting', True, 'public', 200, r"Tek'ma'te"),
('/test_http/greeting', True, 'jackoneill', 200, r"Tek'ma'te"),
('/test_http/greeting-none', False, None, 200, r"Tek'ma'te"),
('/test_http/greeting-none', True, None, 200, r"Tek'ma'te"),
('/test_http/greeting-none', True, 'public', 200, r"Tek'ma'te"),
('/test_http/greeting-none', True, 'jackoneill', 200,
r"Tek'ma'te"),
('/test_http/greeting-public', False, None, 404, r"Not Found"),
('/test_http/greeting-public', True, None, 200, r"Tek'ma'te"),
('/test_http/greeting-public', True, 'public', 200, r"Tek'ma'te"),
('/test_http/greeting-public', True, 'jackoneill', 200,
r"Tek'ma'te"),
('/test_http/greeting-user', False, None, 404, r"Not Found"),
('/test_http/greeting-user', True, None, 303, r".*/web/login.*"),
('/test_http/greeting-user', True, 'public', 303,
r".*/web/login.*"),
('/test_http/greeting-user', True, 'jackoneill', 200,
r"Tek'ma'te"),
]
for path, withdb, login, expected_code, expected_pattern in test_matrix:
with self.subTest(path=path, withdb=withdb, login=login):
if withdb:
if login == 'public':
self.authenticate(None, None)
elif login:
self.authenticate(login, login)
res = self.db_url_open(path, allow_redirects=False)
else:
res = self.nodb_url_open(path, allow_redirects=False)
self.assertEqual(res.status_code, expected_code)
self.assertRegex(res.text, expected_pattern)
if withdb and login:
self.logout(keep_db=False)
def test_spreadsheet_to_display_access_field_groups(self):
existing_groups = self.env['documents.document']._fields['name'].groups
self.env['documents.document']._fields[
'name'].groups = "base.group_system"
user = new_test_user(self.env,
"Test user",
groups='documents.group_documents_manager')
with self.assertRaises(AccessError, msg="field should be protected"):
self.env["documents.document"].with_user(
user).get_spreadsheets_to_display()
self.env['documents.document']._fields['name'].groups = existing_groups
def test_is_favorited(self):
user = new_test_user(self.env,
"test user",
groups='documents.group_documents_user')
document = self.env['documents.document'].create({
'datas':
GIF,
'folder_id':
self.folder_b.id
})
document.favorited_ids = user
self.assertFalse(document.is_favorited)
self.assertTrue(document.with_user(user).is_favorited)
