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)