def test_manager_create_vehicle(self):
manager = new_test_user(
self.env,
"test fleet manager",
groups="fleet.fleet_group_manager,base.group_partner_manager")
user = new_test_user(self.env,
"test base user",
groups="base.group_user")
fleet = self.env['fleet.category'].with_user(manager).create({
'name':
'Test Fleet',
'description':
'Testing Fleet',
})
brand = self.env["fleet.vehicle.model.brand"].create({
"name": "Audi",
})
model = self.env["fleet.vehicle.model"].create({
"brand_id": brand.id,
"name": "A3",
})
self.env["fleet.vehicle"].with_user(manager).create({
"model_id":
model.id,
"driver_id":
user.partner_id.id,
"fleet_id":
fleet.id,
"plan_to_change_car":
False
})
def test_profile_view_fields(self):
""" A simple user should see all fields in profile view, even if they are protected by groups """
view = self.env.ref('hr.res_users_view_form_profile')
# For reference, check the view with user with every groups protecting user fields
all_groups_xml_ids = chain(*[
field.groups.split(',')
for field in self.env['res.users']._fields.values() if field.groups
])
all_groups = self.env['res.groups']
for xml_id in all_groups_xml_ids:
all_groups |= self.env.ref(xml_id.strip())
user_all_groups = new_test_user(self.env,
groups='base.group_user',
login='******',
name='God')
user_all_groups.write(
{'groups_id': [(4, group.id, False) for group in all_groups]})
view_infos = self.env['res.users'].with_user(
user_all_groups).fields_view_get(view_id=view.id)
full_fields = view_infos['fields']
# Now check the view for a simple user
user = new_test_user(self.env, login='******', name='Grouillot')
view_infos = self.env['res.users'].with_user(user).fields_view_get(
view_id=view.id)
fields = view_infos['fields']
# Compare both
self.assertEqual(full_fields.keys(), fields.keys(),
"View fields should not depend on user's groups")
def setUp(self):
super(TestUserAccess, self).setUp()
# create a planning manager
self.planning_mgr = new_test_user(self.env,
login='******',
groups='planning.group_planning_manager',
name='Planning Manager',
email='*****@*****.**')
self.hr_planning_mgr = self.env['hr.employee'].create({
'name': 'Planning Manager',
'user_id': self.planning_mgr.id,
})
# create a planning user
self.planning_user = new_test_user(self.env,
login='******',
groups='planning.group_planning_user',
name='Planning User',
email='*****@*****.**')
self.hr_planning_user = self.env['hr.employee'].create({
'name': 'Planning User',
'user_id': self.planning_user.id,
})
# create an internal user
self.internal_user = new_test_user(self.env,
login='******',
groups='base.group_user',
name='Internal User',
email='*****@*****.**')
self.hr_internal_user = self.env['hr.employee'].create({
'name': 'Internal User',
'user_id': self.internal_user.id,
})
# create several slots for users
self.env['planning.slot'].create({
'start_datetime': datetime(2019, 6, 27, 8, 0, 0),
'end_datetime': datetime(2019, 6, 27, 17, 0, 0),
'employee_id': self.hr_planning_user.id,
'repeat': True,
'repeat_type': 'until',
'repeat_until': datetime(2022, 6, 27, 17, 0, 0),
'repeat_interval': 1,
})
self.env['planning.slot'].create({
'start_datetime': datetime(2019, 6, 28, 8, 0, 0),
'end_datetime': datetime(2019, 6, 28, 17, 0, 0),
'employee_id': self.hr_internal_user.id,
'repeat': True,
'repeat_type': 'until',
'repeat_until': datetime(2022, 6, 28, 17, 0, 0),
'repeat_interval': 1,
'is_published': True,
})
def test_profile_view_fields(self):
""" A simple user should see all fields in profile view, even if they are protected by groups """
view = self.env.ref('hr.res_users_view_form_profile')
# For reference, check the view with user with every groups protecting user fields
all_groups_xml_ids = chain(*[
field.groups.split(',')
for field in self.env['res.users']._fields.values()
if field.groups
if field.groups != '.' # "no-access" group on purpose
])
all_groups = self.env['res.groups']
for xml_id in all_groups_xml_ids:
all_groups |= self.env.ref(xml_id.strip())
user_all_groups = new_test_user(self.env, groups='base.group_user', login='******', name='God')
user_all_groups.write({'groups_id': [(4, group.id, False) for group in all_groups]})
view_infos = self.env['res.users'].with_user(user_all_groups).get_view(view.id)
full_fields = [el.get('name') for el in etree.fromstring(view_infos['arch']).xpath('//field[not(ancestor::field)]')]
# Now check the view for a simple user
user = new_test_user(self.env, login='******', name='Grouillot')
view_infos = self.env['res.users'].with_user(user).get_view(view.id)
fields = [el.get('name') for el in etree.fromstring(view_infos['arch']).xpath('//field[not(ancestor::field)]')]
# Compare both
self.assertEqual(full_fields, fields, "View fields should not depend on user's groups")
def setUp(self):
super().setUp()
# Archive demo partners
self.env['res.users'].search([]).active = False
self.env['res.partner'].search([]).active = False
new_test_user(self.env, login='******', password='******')
self.authenticate('fef', 'pwd')
self.env['res.partner'].create([{
'name': 'partner 1',
'comment': 'yop',
'website': 'yop.com',
'credit_limit': 0,
}, {
'name': 'partner 2',
'comment': 'yop',
'website': 'blop.com',
'credit_limit': 3,
}, {
'name': 'partner 3',
'comment': 'yop',
'website': 'blop.com',
'credit_limit': 1,
}, {
'name': 'partner 4',
'comment': 'blop',
'website': 'blop.com',
'credit_limit': 2,
}])
self.worksheet = {} # mock worksheet
self.default_params = {
'domain': [],
'fields': [{
'label': "Partner name",
'name': 'name',
}, {
'label': "Comment",
'name': "comment",
}, {
'label': 'Website',
'name': 'website',
}],
'groupby': [],
'ids':
False,
'import_compat':
False,
'model':
'res.partner',
}
def setUp(self):
super(TestHrAttendance, self).setUp()
self.user = new_test_user(self.env, login='******', groups='base.group_user,hr_attendance.group_hr_attendance_use_pin')
self.user_no_pin = new_test_user(self.env, login='******', groups='base.group_user')
self.test_employee = self.env['hr.employee'].create({
'name': "François Russie",
'user_id': self.user.id,
'pin': '1234',
})
self.employee_kiosk = self.env['hr.employee'].create({
'name': "Machiavel",
'pin': '5678',
})
def setUp(self):
super(TestSelfAccessRights, self).setUp()
self.richard = new_test_user(self.env,
login='******',
groups='base.group_user',
name='Simple employee',
email='*****@*****.**')
self.richard_emp = self.env['hr.employee'].create({
'name':
'Richard',
'user_id':
self.richard.id,
'address_home_id':
self.env['res.partner'].create({
'name': 'Richard',
'phone': '21454',
'type': 'private'
}).id,
})
self.hubert = new_test_user(self.env,
login='******',
groups='base.group_user',
name='Simple employee',
email='*****@*****.**')
self.hubert_emp = self.env['hr.employee'].create({
'name':
'Hubert',
'user_id':
self.hubert.id,
'address_home_id':
self.env['res.partner'].create({
'name': 'Hubert',
'type': 'private'
}).id,
})
self.protected_fields_emp = OrderedDict([
(k, v) for k, v in self.env['hr.employee']._fields.items()
if v.groups == 'hr.group_hr_user'
])
# Compute fields and id field are always readable by everyone
self.read_protected_fields_emp = OrderedDict([
(k, v) for k, v in self.env['hr.employee']._fields.items()
if not v.compute and k != 'id'
])
self.self_protected_fields_user = OrderedDict([
(k, v) for k, v in self.env['res.users']._fields.items()
if v.groups == 'hr.group_hr_user'
and k in self.env['res.users'].SELF_READABLE_FIELDS
])
def test_add_followers_on_post(self):
# Add some existing partners, some from another company
company = self.env['res.company'].create({'name': 'Oopo'})
company.flush()
existing_partners = self.env['res.partner'].create([{
'name':
'Jean',
'company_id':
company.id,
}, {
'name': 'Paulus',
}])
self.test_move.message_subscribe(existing_partners.ids)
user = new_test_user(self.env,
login='******',
groups='account.group_account_invoice')
move = self.test_move.with_user(user)
partner = self.env['res.partner'].create({'name': 'Belouga'})
move.partner_id = partner
move.action_post()
self.assertEqual(
move.message_partner_ids,
self.env.user.partner_id | existing_partners | partner)
def test_user_level(self):
self.user = new_test_user(self.env,
login='******',
groups='clg_base.group_clg_user',
department_id=self.department2.id)
self.student.with_user(self.user).write(
{'description': "New Description"})
def setUp(self):
super().setUp()
self.main_pos_config.write({"module_pos_hr": True})
# Admin employee
self.env.ref("hr.employee_admin").write({
"name": "Mitchell Admin",
"pin": False
})
# User employee
emp1 = self.env.ref("hr.employee_han")
emp1_user = new_test_user(
self.env,
login="******",
groups="base.group_user",
name="Pos Employee1",
email="*****@*****.**",
)
emp1.write({
"name": "Pos Employee1",
"pin": "2580",
"user_id": emp1_user.id
})
# Non-user employee
emp2 = self.env.ref("hr.employee_jve")
emp2.write({"name": "Pos Employee2", "pin": "1234"})
with Form(self.main_pos_config) as config:
config.employee_ids.add(emp1)
config.employee_ids.add(emp2)
def test_readonly_fields(self):
""" Employee related fields should be readonly if self editing is not allowed """
self.env['ir.config_parameter'].sudo().set_param(
'hr.hr_employee_self_edit', False)
james = new_test_user(self.env,
login='******',
groups='base.group_user',
name='Simple employee',
email='*****@*****.**')
james = james.with_user(james)
self.env['hr.employee'].create({
'name': 'James',
'user_id': james.id,
})
view = self.env.ref('hr.res_users_view_form_profile')
view_infos = james.fields_view_get(view_id=view.id)
employee_related_fields = {
field_name
for field_name, field_attrs in view_infos['fields'].items()
if field_attrs.get('related', (None, ))[0] == 'employee_id'
}
form = Form(james, view=view)
for field in employee_related_fields:
with self.assertRaises(
AssertionError,
msg=
"Field '%s' should be readonly in the employee profile when self edition is not allowed."
% field):
form.__setattr__(field, 'some value')
def setUp(self):
super(TestHrAttendanceLocation, self).setUp()
self.user = new_test_user(self.env, login='******', groups='base.group_user')
self.hr_attendance_obj = self.env['hr.attendance']
self.test_employee = self.env['hr.employee'].create({
'name': "Employee A",
'user_id': self.user.id,
})
def setUpClass(cls):
super(TestHrAttendance, cls).setUpClass()
cls.user = new_test_user(
cls.env,
login='******',
groups='base.group_user,hr_attendance.group_hr_attendance_use_pin')
cls.user_no_pin = new_test_user(cls.env,
login='******',
groups='base.group_user')
cls.test_employee = cls.env['hr.employee'].create({
'name': "François Russie",
'user_id': cls.user.id,
'pin': '1234',
})
cls.employee_kiosk = cls.env['hr.employee'].create({
'name': "Machiavel",
'pin': '5678',
})
def test_company_create(self):
main_company = self.env.ref('base.main_company')
user = new_test_user(self.env, login='******',
groups='base.group_user,base.group_erp_manager,base.group_partner_manager',
company_id=main_company.id,
company_ids=[(6, 0, main_company.ids)])
Company = self.env['res.company']
Company = Company.with_user(user)
Company = Company.with_company(main_company)
company = Company.create({'name': "Wall Company"})
self.assertEqual(company.internal_project_id.sudo().company_id, company, "It should have created a project for the company")
def test_access_my_profile(self):
""" A simple user should be able to read all fields in his profile """
james = new_test_user(self.env, login='******', groups='base.group_user', name='Simple employee', email='*****@*****.**')
james = james.with_user(james)
self.env['hr.employee'].create({
'name': 'James',
'user_id': james.id,
})
view = self.env.ref('hr.res_users_view_form_profile')
view_infos = james.get_view(view.id)
fields = [el.get('name') for el in etree.fromstring(view_infos['arch']).xpath('//field[not(ancestor::field)]')]
james.read(fields)
def setUp(self):
super().setUp()
self.company = self.env['res.company'].create({
'name':
'SweatChopChop Inc.',
'hr_attendance_overtime':
True,
'overtime_start_date':
datetime(2021, 1, 1),
'overtime_company_threshold':
10,
'overtime_employee_threshold':
10,
})
self.env.company = self.company
self.user = new_test_user(
self.env,
login='******',
groups='base.group_user,hr_attendance.group_hr_attendance',
company_id=self.company.id)
self.employee = self.env['hr.employee'].create({
'name':
"Marie-Edouard De La Court",
'user_id':
self.user.id,
'company_id':
self.company.id,
'tz':
'UTC',
})
self.other_employee = self.env['hr.employee'].create({
'name':
'Yolanda',
'company_id':
self.company.id,
})
self.jpn_employee = self.env['hr.employee'].create({
'name':
'Sacha',
'company_id':
self.company.id,
'tz':
'Asia/Tokyo',
})
self.honolulu_employee = self.env['hr.employee'].create({
'name':
'Susan',
'company_id':
self.company.id,
'tz':
'Pacific/Honolulu',
})
def test_access_my_profile_toolbar(self):
""" A simple user shouldn't have the possibilities to see the 'Change Password' action"""
james = new_test_user(self.env,
login='******',
groups='base.group_user',
name='Simple employee',
email='*****@*****.**')
james = james.with_user(james)
self.env['hr.employee'].create({
'name': 'James',
'user_id': james.id,
})
view = self.env.ref('hr.res_users_view_form_profile')
available_actions = james.fields_view_get(
view_id=view.id, toolbar=True)['toolbar']['action']
change_password_action = self.env.ref(
"base.change_password_wizard_action")
self.assertFalse(
any(x['id'] == change_password_action.id
for x in available_actions))
# An ERP manager should have the possibilities to see the 'Change Password'
john = new_test_user(self.env,
login='******',
groups='base.group_erp_manager',
name='ERP Manager',
email='*****@*****.**')
john = john.with_user(john)
self.env['hr.employee'].create({
'name': 'John',
'user_id': john.id,
})
view = self.env.ref('hr.res_users_view_form_profile')
available_actions = john.fields_view_get(
view_id=view.id, toolbar=True)['toolbar']['action']
self.assertTrue(
any(x['id'] == change_password_action.id
for x in available_actions))
def setUp(self):
super(TestSelfAccessRights, self).setUp()
self.richard = new_test_user(self.env, login='******', groups='base.group_user', name='Simple employee', email='*****@*****.**')
self.richard_emp = self.env['hr.employee'].create({
'name': 'Richard',
'user_id': self.richard.id,
'address_home_id': self.env['res.partner'].create({'name': 'Richard', 'phone': '21454', 'type': 'private'}).id,
})
self.hubert = new_test_user(self.env, login='******', groups='base.group_user', name='Simple employee', email='*****@*****.**')
self.hubert_emp = self.env['hr.employee'].create({
'name': 'Hubert',
'user_id': self.hubert.id,
'address_home_id': self.env['res.partner'].create({'name': 'Hubert', 'type': 'private'}).id,
})
self.protected_fields_emp = OrderedDict([(k, v) for k, v in self.env['hr.employee']._fields.items() if v.groups == 'hr.group_hr_user'])
# Compute fields and id field are always readable by everyone
self.read_protected_fields_emp = OrderedDict([(k, v) for k, v in self.env['hr.employee']._fields.items() if not v.compute and k != 'id'])
self.self_protected_fields_user = OrderedDict([
(k, v)
for k, v in self.env['res.users']._fields.items()
if v.groups == 'hr.group_hr_user' and k in self.env['res.users'].SELF_READABLE_FIELDS
])
def setUpClass(cls, chart_template_ref=None):
super().setUpClass(chart_template_ref=chart_template_ref)
cls.env.user.groups_id += cls.env.ref('hr.group_hr_user')
cls.main_pos_config.write({"module_pos_hr": True})
# Admin employee
admin = cls.env.ref("hr.employee_admin").sudo().copy({
"company_id":
cls.env.company.id,
"user_id":
cls.env.user.id,
"name":
"Mitchell Admin",
"pin":
False,
})
# User employee
emp1 = cls.env.ref("hr.employee_han").sudo().copy({
"company_id":
cls.env.company.id,
})
emp1_user = new_test_user(
cls.env,
login="******",
groups="base.group_user",
name="Pos Employee1",
email="*****@*****.**",
)
emp1.write({
"name": "Pos Employee1",
"pin": "2580",
"user_id": emp1_user.id
})
# Non-user employee
emp2 = cls.env.ref("hr.employee_jve").sudo().copy({
"company_id":
cls.env.company.id,
})
emp2.write({"name": "Pos Employee2", "pin": "1234"})
(admin + emp1 + emp2).company_id = cls.env.company
cls.main_pos_config.write(
{'employee_ids': [Command.link(emp1.id),
Command.link(emp2.id)]})
def test_access_my_profile(self):
""" A simple user should be able to read all fields in his profile """
james = new_test_user(self.env,
login='******',
groups='base.group_user',
name='Simple employee',
email='*****@*****.**')
james = james.with_user(james)
self.env['hr.employee'].create({
'name': 'James',
'user_id': james.id,
})
view = self.env.ref('hr.res_users_view_form_profile')
view_infos = james.fields_view_get(view_id=view.id)
fields = view_infos['fields'].keys()
james.read(fields)
def test_search_renewal(self):
"""
Should find the car with overdue contract or renewal due soon
"""
user = new_test_user(self.env,
"test base user",
groups="base.group_user")
brand = self.env["fleet.vehicle.model.brand"].create({
"name": "Audi",
})
model = self.env["fleet.vehicle.model"].create({
"brand_id": brand.id,
"name": "A3",
})
car_1 = self.env["fleet.vehicle"].create({
"model_id": model.id,
"driver_id": user.partner_id.id,
"plan_to_change_car": False
})
car_2 = self.env["fleet.vehicle"].create({
"model_id": model.id,
"driver_id": user.partner_id.id,
"plan_to_change_car": False
})
Log = self.env['fleet.vehicle.log.contract']
log = Log.create({
'vehicle_id':
car_2.id,
'expiration_date':
fields.Date.add(fields.Date.today(), days=10)
})
res = self.env["fleet.vehicle"].search([('contract_renewal_due_soon',
'=', True),
('id', '=', car_2.id)])
self.assertEqual(res, car_2)
log = Log.create({
'vehicle_id':
car_1.id,
'expiration_date':
fields.Date.add(fields.Date.today(), days=-10)
})
res = self.env["fleet.vehicle"].search([('contract_renewal_overdue',
'=', True),
('id', '=', car_1.id)])
self.assertEqual(res, car_1)
def test_partial_delivering_single_so(self):
#
# SO ┐ ┌ DdT
# ├ Picking ┘
# │
# └ Picking ┐
# └ DdT
#
user = new_test_user(
self.env,
login="******",
groups="stock.group_stock_manager",
)
# change user in order to automatically create delivery note
# when picking is validated
self.env.user = user
StockPicking = self.env["stock.picking"]
sales_order = self.create_sales_order(
[
self.large_desk_line, # 1
self.desk_combination_line, # 1
], )
self.assertEqual(len(sales_order.order_line), 2)
sales_order.action_confirm()
self.assertEqual(len(sales_order.picking_ids), 1)
picking = sales_order.picking_ids
self.assertEqual(len(picking.move_lines), 2)
# deliver only the first product
picking.move_lines[0].quantity_done = 1
res_dict = picking.button_validate()
wizard = Form(self.env[(res_dict.get("res_model"))].with_context(
res_dict["context"])).save()
self.assertEqual(wizard._name, "stock.backorder.confirmation")
wizard.process()
self.assertTrue(picking.delivery_note_id)
picking_backorder = StockPicking.search([("backorder_id", "=",
picking.id)])
self.assertEqual(len(picking_backorder.move_lines), 1)
picking_backorder.move_lines[0].quantity_done = 1
picking_backorder.button_validate()
self.assertTrue(picking_backorder.delivery_note_id)
def test_readonly_fields(self):
""" Employee related fields should be readonly if self editing is not allowed """
self.env['ir.config_parameter'].sudo().set_param('hr.hr_employee_self_edit', False)
james = new_test_user(self.env, login='******', groups='base.group_user', name='Simple employee', email='*****@*****.**')
james = james.with_user(james)
self.env['hr.employee'].create({
'name': 'James',
'user_id': james.id,
})
view = self.env.ref('hr.res_users_view_form_profile')
fields = james._fields
view_infos = james.get_view(view.id)
employee_related_fields = {
el.get('name')
for el in etree.fromstring(view_infos['arch']).xpath('//field[not(ancestor::field)]')
if fields[el.get('name')].related and fields[el.get('name')].related.split('.')[0] == 'employee_id'
}
form = Form(james, view=view)
for field in employee_related_fields:
with self.assertRaises(AssertionError, msg="Field '%s' should be readonly in the employee profile when self editing is not allowed." % field):
form.__setattr__(field, 'some value')
def setUp(self):
super().setUp()
self.company = self.env['res.company'].create({
'name': 'Taxi Dermi',
})
self.manager = new_test_user(self.env,
login='******',
groups='fleet.fleet_group_manager',
company_id=self.company.id)
self.addresses = self.env['res.partner'].create([
{
'name': 'Address 1',
'company_id': self.company.id,
'type': 'private',
},
{
'name': 'Address 2',
'company_id': self.company.id,
'type': 'private',
},
{
'name': 'Address 3',
'company_id': self.company.id,
'type': 'private',
},
{
'name': 'Address 4',
'company_id': self.company.id,
'type': 'private',
},
])
self.employees = self.env['hr.employee'].create([
{
'name': 'Employee 1',
'company_id': self.company.id,
'address_home_id': self.addresses[0].id,
},
{
'name': 'Employee 2',
'company_id': self.company.id,
'address_home_id': self.addresses[1].id,
},
{
'name': 'Employee 3',
'company_id': self.company.id,
'address_home_id': self.addresses[2].id,
},
{
'name': 'Employee 4',
'company_id': self.company.id,
'address_home_id': self.addresses[3].id,
},
])
self.brand = self.env['fleet.vehicle.model.brand'].create({
'name':
'Test Brand',
})
self.model = self.env['fleet.vehicle.model'].create({
'name':
'Test Model',
'brand_id':
self.brand.id,
})
self.external_fleet = self.env['fleet.category'].create({
'name':
'External Fleet',
'company_id':
self.company.id,
'internal':
False,
})
self.internal_fleet = self.env['fleet.category'].create({
'name':
'Internal Fleet',
'company_id':
self.company.id,
'internal':
True,
})
vehicle_create_vals = []
for fleet in (self.external_fleet | self.internal_fleet):
for i in range(4):
vehicle_create_vals.append({
'name':
'Test Car ' + str(i) + ' ' + fleet.name,
'fleet_id':
fleet.id,
'company_id':
self.company.id,
'model_id':
self.model.id,
})
self.env['fleet.vehicle'].create(vehicle_create_vals)
def setUpClass(cls):
super().setUpClass()
cls.env.cr.commit = Mock()
cls.env = cls.env(context=dict(
cls.env.context,
tracking_disable=True,
test_queue_job_no_delay=True,
))
cls.partner_1 = cls.env.ref("base.res_partner_1")
cls.partner_2 = cls.env.ref("base.res_partner_2")
cls.partner_3 = cls.env.ref("base.res_partner_3")
cls.country_be = cls.env.ref("base.be")
cls.country_us = cls.env.ref("base.us")
cls.group_manager = cls.env.ref("base.group_erp_manager")
cls.group_no_one = cls.env.ref("base.group_no_one")
cls.group_job = cls.env.ref("queue_job.group_queue_job_manager")
cls.field_user_name = cls.env.ref("base.field_res_users__name")
cls.field_user_id = cls.env.ref("base.field_res_users__id")
cls.field_user_login = cls.env.ref("base.field_res_users__login")
cls.industry1 = cls.env.ref("base.res_partner_industry_A")
cls.industry2 = cls.env.ref("base.res_partner_industry_B")
cls.industries = cls.industry1 | cls.industry2
cls.partner_cat1 = cls.env.ref("base.res_partner_category_3")
cls.partner_cat2 = cls.env.ref("base.res_partner_category_11")
cls.partner_catgs = cls.partner_cat1 | cls.partner_cat2
cls.user1 = new_test_user(cls.env,
login="******",
name=cls.partner_1.name,
partner_id=cls.partner_1.id)
cls.user2 = new_test_user(cls.env,
login="******",
name=cls.partner_1.name,
partner_id=cls.partner_1.id)
cls.user3 = new_test_user(
cls.env,
login="******",
name=cls.partner_2.name,
partner_id=cls.partner_2.id,
)
cls.users = cls.user1 | cls.user2 | cls.user3
# generate xmlid
cls.users.export_data(["id"])
cls.partners = cls.partner_1 | cls.partner_2 | cls.partner_3
cls.company1 = cls.env.ref("base.main_company")
cls.company2 = cls.env["res.company"].create({
"name":
"Awesome company",
"user_ids": [(
6,
0,
[
cls.user1.id, cls.user2.id,
cls.env.ref("base.user_admin").id
],
)],
})
cls.company3 = cls.env["res.company"].create({
"name":
"Bad company",
"user_ids":
[(6, 0, [cls.user1.id,
cls.env.ref("base.user_admin").id])],
})
cls.company4 = cls.env["res.company"].create(
{"name": "Ignored company"})
cls.companies = cls.company1 | cls.company2 | cls.company3
cls.separator = COLUMN_X2M_SEPARATOR
cls.pattern_config = cls.env.ref(
"pattern_import_export.demo_pattern_config")
cls.pattern_config_m2m = cls.env.ref(
"pattern_import_export.demo_pattern_config_m2m")
cls.pattern_config_o2m = cls.env.ref(
"pattern_import_export.demo_pattern_config_o2m")
cls.filter_ignore_one = cls.env.ref(
"pattern_import_export.demo_filter_companies")
cls.filter_countries_1 = cls.env.ref(
"pattern_import_export.demo_filter_countries_1")
cls.filter_countries_2 = cls.env.ref(
"pattern_import_export.demo_filter_countries_2")
def setUpClass(cls):
super().setUpClass()
cls.company = cls.env['res.company'].create({
'name':
'SweatChipChop Inc.',
'hr_attendance_overtime':
True,
'overtime_start_date':
datetime(2021, 1, 1),
})
cls.user = new_test_user(
cls.env,
login='******',
groups='base.group_user,hr_attendance.group_hr_attendance',
company_id=cls.company.id).with_company(cls.company)
cls.user_manager = new_test_user(
cls.env,
login='******',
groups='base.group_user,hr_holidays.group_hr_holidays_user',
company_id=cls.company.id).with_company(cls.company)
cls.manager = cls.env['hr.employee'].create({
'name':
'Dominique',
'user_id':
cls.user_manager.id,
'company_id':
cls.company.id,
})
cls.employee = cls.env['hr.employee'].create({
'name':
'Barnabé',
'user_id':
cls.user.id,
'parent_id':
cls.manager.id,
'company_id':
cls.company.id,
})
cls.leave_type_no_alloc = cls.env['hr.leave.type'].create({
'name':
'Overtime Compensation No Allocation',
'company_id':
cls.company.id,
'requires_allocation':
'no',
'overtime_deductible':
True,
})
cls.leave_type_employee_allocation = cls.env['hr.leave.type'].create({
'name':
'Overtime Compensation Employee Allocation',
'company_id':
cls.company.id,
'requires_allocation':
'yes',
'employee_requests':
'yes',
'overtime_deductible':
True,
})
def setUpClass(cls):
super().setUpClass()
cls.default_calendar = cls.env['resource.calendar'].create({
'name':
'moon calendar',
})
cls.company = cls.env['res.company'].create({
'name':
'super company',
'resource_calendar_id':
cls.default_calendar.id,
})
cls.employee_user = new_test_user(cls.env,
login='******',
groups='base.group_user',
company_ids=[(6, 0, cls.company.ids)
],
company_id=cls.company.id)
cls.manager_user = new_test_user(
cls.env,
login='******',
groups='base.group_user,hr_holidays.group_hr_holidays_manager',
company_ids=[(6, 0, cls.company.ids)],
company_id=cls.company.id)
cls.employee_emp = cls.env['hr.employee'].create({
'name':
'Toto Employee',
'company_id':
cls.company.id,
'user_id':
cls.employee_user.id,
'resource_calendar_id':
cls.default_calendar.id,
})
cls.manager_emp = cls.env['hr.employee'].create({
'name':
'Toto Mananger',
'company_id':
cls.company.id,
'user_id':
cls.manager_user.id,
})
cls.leave_type = cls.env['hr.leave.type'].create({
'name':
'Unlimited',
'leave_validation_type':
'hr',
'requires_allocation':
'no',
'company_id':
cls.company.id,
})
cls.stress_day = cls.env['hr.leave.stress.day'].create({
'name':
'Super Event',
'company_id':
cls.company.id,
'start_date':
datetime(2021, 11, 2),
'end_date':
datetime(2021, 11, 2),
'color':
1,
'resource_calendar_id':
cls.default_calendar.id,
})
cls.stress_week = cls.env['hr.leave.stress.day'].create({
'name':
'Super Event End Of Week',
'company_id':
cls.company.id,
'start_date':
datetime(2021, 11, 8),
'end_date':
datetime(2021, 11, 12),
'color':
2,
'resource_calendar_id':
cls.default_calendar.id,
})
def setUp(self):
super().setUp()
self.password = "******"
self.user = new_test_user(self.env,
login="******",
password=self.password)
def setUp(self):
super(TestsCommon, self).setUp()
self.env['lunch.cashmove'].create({
'amount': 100,
})
self.manager = new_test_user(
self.env, 'cle-lunch-manager',
'base.group_user,base.group_partner_manager,lunch.group_lunch_manager'
)
with self.with_user('cle-lunch-manager'):
self.location_office_1 = self.env['lunch.location'].create({
'name':
'Farm 1',
})
self.location_office_2 = self.env['lunch.location'].create({
'name':
'Farm 2',
})
self.partner_pizza_inn = self.env['res.partner'].create({
'name':
'Pizza Inn',
})
self.supplier_pizza_inn = self.env['lunch.supplier'].create({
'partner_id':
self.partner_pizza_inn.id,
'send_by':
'mail',
'automatic_email_time':
11,
'available_location_ids':
[(6, 0, [self.location_office_1.id,
self.location_office_2.id])],
})
self.partner_kothai = self.env['res.partner'].create({
'name':
'Kothai',
})
self.supplier_kothai = self.env['lunch.supplier'].create({
'partner_id':
self.partner_kothai.id,
'send_by':
'mail',
'automatic_email_time':
10,
'tz':
'America/New_York',
})
self.partner_coin_gourmand = self.env['res.partner'].create({
'name':
'Coin Gourmand',
})
self.supplier_coin_gourmand = self.env['lunch.supplier'].create({
'partner_id':
self.partner_coin_gourmand.id,
'send_by':
'phone',
'available_location_ids':
[(6, 0, [self.location_office_1.id,
self.location_office_2.id])],
})
self.category_pizza = self.env['lunch.product.category'].create({
'name':
'Pizza',
})
self.category_sandwich = self.env['lunch.product.category'].create(
{
'name': 'Sandwich',
})
self.product_pizza = self.env['lunch.product'].create({
'name':
'Pizza',
'category_id':
self.category_pizza.id,
'price':
9,
'supplier_id':
self.supplier_pizza_inn.id,
})
self.product_sandwich_tuna = self.env['lunch.product'].create({
'name':
'Tuna Sandwich',
'category_id':
self.category_sandwich.id,
'price':
3,
'supplier_id':
self.supplier_coin_gourmand.id,
})
self.topping_olives = self.env['lunch.topping'].create({
'name':
'Olives',
'price':
0.3,
'supplier_id':
self.supplier_pizza_inn.id,
})
self.env['lunch.cashmove'].create({
'amount': 100,
})
self.alert_ny = self.env['lunch.alert'].create({
'name':
'New York UTC-5',
'mode':
'chat',
'notification_time':
10,
'notification_moment':
'am',
'tz':
'America/New_York',
'message':
"",
}).with_context(tz='America/New_York')
self.alert_tokyo = self.env['lunch.alert'].create({
'name':
'Tokyo UTC+9',
'mode':
'chat',
'notification_time':
8,
'notification_moment':
'am',
'tz':
'Asia/Tokyo',
'message':
"",
}).with_context(tz='Asia/Tokyo')
def test_import_and_update_module(self):
self.test_user = new_test_user(
self.env,
login='******',
groups='base.group_user,base.group_system',
name='Admin',
)
bundle = 'web.assets_backend'
path = 'test_module/static/src/js/test.js'
manifest_content = json.dumps({
'name': 'Test Module',
'description': 'Test',
'assets': {
bundle: [path]
},
'license': 'LGPL-3',
})
stream = BytesIO()
with ZipFile(stream, 'w') as archive:
archive.writestr('test_module/__manifest__.py', manifest_content)
archive.writestr(path, "console.log('AAA');")
# Import test module
self.env['ir.module.module'].with_user(
self.test_user).import_zipfile(stream)
attachment = self.env['ir.attachment'].search([('url', '=', f'/{path}')
])
self.assertEqual(attachment.name, 'test.js')
self.assertEqual(attachment.type, 'binary')
self.assertEqual(attachment.raw, b"console.log('AAA');")
asset = self.env['ir.asset'].search([
('name', '=', f'test_module.{bundle}./{path}')
])
self.assertEqual(asset.path, f'/{path}')
self.assertEqual(asset.bundle, bundle)
self.assertEqual(asset.directive, 'append')
self.assertEqual(asset.target, False)
asset_data = self.env['ir.model.data'].search([
('model', '=', 'ir.asset'), ('res_id', '=', asset.id)
])
self.assertEqual(asset_data.module, 'test_module')
self.assertEqual(asset_data.name,
f'{bundle}_/{path}'.replace(".", "_"))
# Update test module
stream = BytesIO()
with ZipFile(stream, 'w') as archive:
archive.writestr('test_module/__manifest__.py', manifest_content)
archive.writestr(path, "console.log('BBB');")
# Import test module
self.env['ir.module.module'].with_user(
self.test_user).import_zipfile(stream)
attachment = self.env['ir.attachment'].search([('url', '=', f'/{path}')
])
self.assertEqual(attachment.name, 'test.js')
self.assertEqual(attachment.type, 'binary')
self.assertEqual(attachment.raw, b"console.log('BBB');")
asset = self.env['ir.asset'].search([
('name', '=', f'test_module.{bundle}./{path}')
])
self.assertEqual(asset.path, f'/{path}')
self.assertEqual(asset.bundle, bundle)
self.assertEqual(asset.directive, 'append')
self.assertEqual(asset.target, False)
asset_data = self.env['ir.model.data'].search([
('model', '=', 'ir.asset'), ('res_id', '=', asset.id)
])
self.assertEqual(asset_data.module, 'test_module')
self.assertEqual(asset_data.name,
f'{bundle}_/{path}'.replace(".", "_"))
def setUp(self):
super().setUp()
self.company = self.env['res.company'].create({
'name':
'SweatChipChop Inc.',
'hr_attendance_overtime':
True,
'overtime_start_date':
datetime(2021, 1, 1)
})
self.env.company = self.company
self.user = new_test_user(
self.env,
login='******',
groups='base.group_user,hr_attendance.group_hr_attendance',
company_id=self.company.id)
self.user_manager = new_test_user(
self.env,
login='******',
groups='base.group_user,hr_holidays.group_hr_holidays_user',
company_id=self.company.id)
self.manager = self.env['hr.employee'].create({
'name':
'Dominique',
'user_id':
self.user_manager.id,
'company_id':
self.company.id,
})
self.employee = self.env['hr.employee'].create({
'name':
'Barnabé',
'user_id':
self.user.id,
'parent_id':
self.manager.id,
'company_id':
self.company.id,
})
self.leave_type_no_alloc = self.env['hr.leave.type'].create({
'name':
'Overtime Compensation No Allocation',
'company_id':
self.company.id,
'allocation_type':
'no',
'overtime_deductible':
True,
})
self.leave_type_employee_allocation = self.env['hr.leave.type'].create(
{
'name': 'Overtime Compensation Employee Allocation',
'company_id': self.company.id,
'allocation_type': 'fixed_allocation',
'overtime_deductible': True,
})
self.leave_type_manager_alloc = self.env['hr.leave.type'].create({
'name':
'Overtime Compensation Manager Allocation',
'company_id':
self.company.id,
'allocation_type':
'fixed',
'overtime_deductible':
True,
})
