def setUp(self):
super(TestWebsiteEventAccess, self).setUp()
self.events = self.env['event.event'].create([{
'name': 'Event 0 - Sitemap test',
'website_published': True,
'date_begin': datetime.today() - timedelta(days=1),
'date_end': datetime.today() + timedelta(days=1),
}, {
'name': 'Event 1 - Sitemap test',
'website_published': True,
'date_begin': datetime.today() - timedelta(days=1),
'date_end': datetime.today() + timedelta(days=1),
}, {
'name': 'Event 2 - Sitemap test',
'date_begin': datetime.today() - timedelta(days=1),
'date_end': datetime.today() + timedelta(days=1),
}])
self.event_manager = mail_new_test_user(
self.env, name='Gandalf le blanc', login='******', password='******', email='*****@*****.**',
groups='event.group_event_manager,base.group_user'
)
self.event_user = mail_new_test_user(
self.env, name='Frodon Sacquet', login='******', password='******', email='*****@*****.**',
groups='event.group_event_user,base.group_user'
)
self.portal_user = mail_new_test_user(
self.env, name='Smeagol', login='******', password='******', email='*****@*****.**',
groups='base.group_portal'
)
def setUp(self):
super(TestPortalWizard, self).setUp()
self.partner = self.env['res.partner'].create({
'name':
'Testing Partner',
'email':
'*****@*****.**',
})
self.public_user = mail_new_test_user(
self.env,
name='Public user',
login='******',
email='*****@*****.**',
groups='base.group_public',
)
self.portal_user = mail_new_test_user(
self.env,
name='Portal user',
login='******',
email='*****@*****.**',
groups='base.group_portal',
)
self.internal_user = mail_new_test_user(
self.env,
name='Internal user',
login='******',
email='*****@*****.**',
groups='base.group_user',
)
def setUpClass(cls):
super(TestAccessRating, cls).setUpClass()
cls.user_manager_partner = mail_new_test_user(
cls.env,
name='Jean Admin',
login='******',
email='*****@*****.**',
groups='base.group_partner_manager,base.group_system')
cls.user_emp = mail_new_test_user(cls.env,
name='Eglantine Employee',
login='******',
email='*****@*****.**',
groups='base.group_user')
cls.user_portal = mail_new_test_user(cls.env,
name='Patrick Portal',
login='******',
email='*****@*****.**',
groups='base.group_portal')
cls.user_public = mail_new_test_user(cls.env,
name='Pauline Public',
login='******',
email='*****@*****.**',
groups='base.group_public')
cls.partner_to_rate = cls.env['res.partner'].with_user(
cls.user_manager_partner).create({"name": "Partner to Rate :("})
def setUp(self):
super().setUp()
self.model = self.env[self.model_name]
mail_new_test_user(self.env,
login='******',
password='******',
groups='base.group_user,base.group_allow_export')
self.session = self.authenticate('fof', '123456789')
self.worksheet = {} # mock worksheet
self.default_params = {
'domain': [],
'fields': [{
'name': field.name,
'label': field.string
} for field in self.model._fields.values()],
'groupby': [],
'ids':
False,
'import_compat':
False,
'model':
self.model._name,
}
def setUp(self):
super().setUp()
TestSubscriptionDashboard._create_test_objects(self)
mail_new_test_user(self.env,
"test_user_1",
email="*****@*****.**",
password="******")
def setUpClass(cls):
super(TestMessageAccess, cls).setUpClass()
cls.user_public = mail_new_test_user(cls.env, login='******', groups='base.group_public', name='Bert Tartignole')
cls.user_portal = mail_new_test_user(cls.env, login='******', groups='base.group_portal', name='Chell Gladys')
Channel = cls.env['mail.channel'].with_context(cls._test_context)
# Pigs: base group for tests
cls.group_pigs = Channel.create({
'name': 'Pigs',
'public': 'groups',
'group_public_id': cls.env.ref('base.group_user').id})
# Jobs: public group
cls.group_public = Channel.create({
'name': 'Jobs',
'description': 'NotFalse',
'public': 'public'})
# Private: private gtroup
cls.group_private = Channel.create({
'name': 'Private',
'public': 'private'})
cls.message = cls.env['mail.message'].create({
'body': 'My Body',
'model': 'mail.channel',
'res_id': cls.group_private.id,
})
def setUpClass(cls):
super(TestChannelAccessRights, cls).setUpClass()
Channel = cls.env['mail.channel'].with_context(cls._test_context)
cls.user_public = mail_new_test_user(cls.env,
login='******',
groups='base.group_public',
name='Bert Tartignole')
cls.user_portal = mail_new_test_user(cls.env,
login='******',
groups='base.group_portal',
name='Chell Gladys')
# Pigs: base group for tests
cls.group_groups = Channel.create({
'name':
'Pigs',
'public':
'groups',
'group_public_id':
cls.env.ref('base.group_user').id
})
# Jobs: public group
cls.group_public = Channel.create({
'name': 'Jobs',
'description': 'NotFalse',
'public': 'public'
})
# Private: private group
cls.group_private = Channel.create({
'name': 'Private',
'public': 'private'
})
def setUpClass(cls):
super(TestProjectUpdateAccessRights, cls).setUpClass()
cls.project_update_1 = cls.env['project.update'].create({
'name':
"Test Project Update",
'project_id':
cls.project_pigs.id,
'status':
'on_track',
})
cls.project_milestone = cls.env['project.milestone'].create({
'name':
'Test Projec Milestone',
'project_id':
cls.project_pigs.id,
})
cls.base_user = mail_new_test_user(cls.env,
'Base user',
groups='base.group_user')
cls.project_user = mail_new_test_user(
cls.env, 'Project user', groups='project.group_project_user')
cls.project_manager = mail_new_test_user(
cls.env, 'Project admin', groups='project.group_project_manager')
cls.portal_user = mail_new_test_user(cls.env,
'Portal user',
groups='base.group_portal')
def setUp(self):
super(TestMassMailPerformanceBase, self).setUp()
self.user_employee = mail_new_test_user(self.env,
login='******',
groups='base.group_user',
name='Ernest Employee',
notification_type='inbox')
self.user_marketing = mail_new_test_user(
self.env,
login='******',
groups='base.group_user,mass_mailing.group_mass_mailing_user',
name='Martial Marketing',
signature='--\nMartial')
# setup mail gateway
self.alias_domain = 'example.com'
self.alias_catchall = 'catchall.test'
self.alias_bounce = 'bounce.test'
self.default_from = 'notifications'
self.env['ir.config_parameter'].set_param('mail.bounce.alias',
self.alias_bounce)
self.env['ir.config_parameter'].set_param('mail.catchall.domain',
self.alias_domain)
self.env['ir.config_parameter'].set_param('mail.catchall.alias',
self.alias_catchall)
self.env['ir.config_parameter'].set_param('mail.default.from',
self.default_from)
# patch registry to simulate a ready environment
self.patch(self.env.registry, 'ready', True)
def setUpClass(cls):
super().setUpClass()
cls.user_admin = mail_new_test_user(
cls.env,
login='******',
groups='base.group_user,base.group_system')
cls.basic_user = mail_new_test_user(cls.env,
login='******',
groups='base.group_user')
sms_enabled_models = cls.env['ir.model'].search([
('is_mail_thread', '=', True), ('transient', '=', False)
])
vals = []
for model in sms_enabled_models:
vals.append({
'name': 'SMS Template ' + model.name,
'body': 'Body Test',
'model_id': model.id,
})
cls.sms_templates = cls.env['sms.template'].create(vals)
cls.sms_dynamic_template = cls.env['sms.template'].sudo().create({
'body':
'${object.name}',
'model_id':
cls.env['ir.model'].sudo().search([('model', '=', 'res.partner')
]).id,
})
cls.partner = cls.env['res.partner'].create({'name': 'Test Partner'})
def test_res_partner_get_mention_suggestions_priority(self):
name = uuid4(
) # unique name to avoid conflict with already existing users
self.env['res.partner'].create([{
'name': f'{name}-{i}-not-user'
} for i in range(0, 2)])
for i in range(0, 2):
mail_new_test_user(self.env,
login=f'{name}-{i}-portal-user',
groups='base.group_portal')
mail_new_test_user(self.env,
login=f'{name}-{i}-internal-user',
groups='base.group_user')
partners_format = self.env['res.partner'].get_mention_suggestions(
name, limit=5)
self.assertEqual(len(partners_format), 5,
"should have found limit (5) partners")
self.assertEqual(
list(map(lambda p: p['is_internal_user'],
partners_format)), [True, True, False, False, False],
"should return internal users in priority")
self.assertEqual(
list(map(lambda p: bool(p['user_id']),
partners_format)), [True, True, True, True, False],
"should return partners without users last")
def setUp(self):
super(TestSurveyCommon, self).setUp()
""" Create test data: a survey with some pre-defined questions and various test users for ACL """
self.survey_manager = mail_new_test_user(
self.env, name='Gustave Doré', login='******', email='*****@*****.**',
groups='survey.group_survey_manager,base.group_user'
)
self.survey_user = mail_new_test_user(
self.env, name='Lukas Peeters', login='******', email='*****@*****.**',
groups='survey.group_survey_user,base.group_user'
)
self.user_emp = mail_new_test_user(
self.env, name='Eglantine Employee', login='******', email='*****@*****.**',
groups='base.group_user', password='******'
)
self.user_portal = mail_new_test_user(
self.env, name='Patrick Portal', login='******', email='*****@*****.**',
groups='base.group_portal'
)
self.user_public = mail_new_test_user(
self.env, name='Pauline Public', login='******', email='*****@*****.**',
groups='base.group_public'
)
self.customer = self.env['res.partner'].create({
'name': 'Caroline Customer',
'email': '*****@*****.**',
})
self.survey = self.env['survey.survey'].with_user(self.survey_manager).create({
'title': 'Test Survey',
'access_mode': 'public',
'users_login_required': True,
'users_can_go_back': False,
})
self.page_0 = self.env['survey.question'].with_user(self.survey_manager).create({
'title': 'First page',
'survey_id': self.survey.id,
'sequence': 1,
'is_page': True,
})
self.question_ft = self.env['survey.question'].with_user(self.survey_manager).create({
'title': 'Test Free Text',
'survey_id': self.survey.id,
'sequence': 2,
'question_type': 'text_box',
})
self.question_num = self.env['survey.question'].with_user(self.survey_manager).create({
'title': 'Test NUmerical Box',
'survey_id': self.survey.id,
'sequence': 3,
'question_type': 'numerical_box',
})
def setUp(self):
super().setUp()
self.task = self.create_task('Make the world a better place')
self.user = mail_new_test_user(self.env,
'Internal user',
groups='base.group_user')
self.portal = mail_new_test_user(self.env,
'Portal user',
groups='base.group_portal')
def setUpClass(cls, chart_template_ref=None):
super().setUpClass(chart_template_ref=chart_template_ref)
group_expense_manager = cls.env.ref(
'hr_expense.group_hr_expense_manager')
cls.expense_user_employee = mail_new_test_user(
cls.env,
name='expense_user_employee',
login='******',
email='*****@*****.**',
notification_type='email',
groups='base.group_user',
company_ids=[(6, 0, cls.env.companies.ids)],
)
cls.expense_user_manager = mail_new_test_user(
cls.env,
name='Expense manager',
login='******',
email='*****@*****.**',
notification_type='email',
groups='base.group_user,hr_expense.group_hr_expense_manager',
company_ids=[(6, 0, cls.env.companies.ids)],
)
cls.expense_employee = cls.env['hr.employee'].create({
'name':
'expense_employee',
'user_id':
cls.expense_user_employee.id,
'address_home_id':
cls.expense_user_employee.partner_id.id,
'address_id':
cls.expense_user_employee.partner_id.id,
})
# Allow the current accounting user to access the expenses.
cls.env.user.groups_id |= group_expense_manager
# Create analytic account
cls.analytic_account_1 = cls.env['account.analytic.account'].create({
'name':
'analytic_account_1',
})
cls.analytic_account_2 = cls.env['account.analytic.account'].create({
'name':
'analytic_account_2',
})
# Ensure products can be expensed.
(cls.product_a + cls.product_b).write({'can_be_expensed': True})
# Taxes on the products are included in price
(cls.product_a.supplier_taxes_id +
cls.product_b.supplier_taxes_id).write({'price_include': True})
cls.company_data['default_tax_purchase'].write({'price_include': True})
def setUpClass(cls):
super(StockQuant, cls).setUpClass()
cls.demo_user = mail_new_test_user(
cls.env,
name='Pauline Poivraisselle',
login='******',
email='*****@*****.**',
notification_type='inbox',
groups='base.group_user',
)
cls.stock_user = mail_new_test_user(
cls.env,
name='Pauline Poivraisselle',
login='******',
email='*****@*****.**',
notification_type='inbox',
groups='stock.group_stock_user',
)
cls.product = cls.env['product.product'].create({
'name': 'Product A',
'type': 'product',
})
cls.product_lot = cls.env['product.product'].create({
'name': 'Product A',
'type': 'product',
'tracking': 'lot',
})
cls.product_consu = cls.env['product.product'].create({
'name': 'Product A',
'type': 'consu',
})
cls.product_serial = cls.env['product.product'].create({
'name':
'Product A',
'type':
'product',
'tracking':
'serial',
})
cls.stock_location = cls.env['stock.location'].create({
'name':
'stock_location',
'usage':
'internal',
})
cls.stock_subloc2 = cls.env['stock.location'].create({
'name':
'subloc2',
'usage':
'internal',
'location_id':
cls.stock_location.id,
})
def test_notification_type_constraint(self):
with self.assertRaises(
IntegrityError,
msg='Portal user can not receive notification in Odoo'):
mail_new_test_user(
self.env,
login='******',
name='Test User 2',
email='*****@*****.**',
notification_type='inbox',
groups='base.group_portal',
)
def setUpClass(cls):
super().setUpClass()
cls._activate_multi_company()
cls.user_portal = cls._create_portal_user()
cls.partner_portal = cls.user_portal.partner_id
cls.user_employee_manager = mail_new_test_user(
cls.env,
company_id=cls.company_admin.id,
country_id=cls.env.ref('base.be').id,
groups='base.group_user',
login='******',
name='Evelyne Employee',
notification_type='inbox',
signature='--\nEvelyne')
cls.partner_employee_manager = cls.user_employee_manager.partner_id
cls.user_employee2 = mail_new_test_user(
cls.env,
company_id=cls.company_admin.id,
country_id=cls.env.ref('base.be').id,
groups='base.group_user',
login='******',
name='Eglantine Employee',
notification_type='inbox',
signature='--\nEglantine')
cls.partner_employee2 = cls.user_employee2.partner_id
cls.user_public = mail_new_test_user(
cls.env,
company_id=cls.company_admin.id,
groups='base.group_public',
login='******',
name='Public Anonymous',
)
cls.partner_public = cls.user_public.partner_id
cls.customer = cls.env['res.partner'].create({
'country_id':
cls.env.ref('base.be').id,
'email':
'*****@*****.**',
'mobile':
'+32455001122',
'name':
'Corentine Customer',
'phone':
'+32455334455',
})
def setUp(self):
super(TestMassMailPerformanceBase, self).setUp()
self.user_employee = mail_new_test_user(
self.env, login='******',
groups='base.group_user',
name='Ernest Employee', notification_type='inbox')
self.user_marketing = mail_new_test_user(
self.env, login='******',
groups='base.group_user,mass_mailing.group_mass_mailing_user',
name='Martial Marketing', signature='--\nMartial')
# patch registry to simulate a ready environment
self.patch(self.env.registry, 'ready', True)
def test_edit_removal_date_in_inventory_mode(self):
""" Try to edit removal_date with the inventory mode.
"""
user_group_stock_manager = self.env.ref('stock.group_stock_manager')
self.demo_user = mail_new_test_user(
self.env,
name='Demo user',
login='******',
email='*****@*****.**',
groups='stock.group_stock_manager',
)
lot_form = Form(self.LotObj)
lot_form.name = 'LOT001'
lot_form.product_id = self.apple_product
lot_form.company_id = self.env.company
apple_lot = lot_form.save()
quant = self.StockQuantObj.with_context(inventory_mode=True).create({
'product_id':
self.apple_product.id,
'location_id':
self.stock_location,
'quantity':
10,
'lot_id':
apple_lot.id,
})
# Try to write on quant with inventory mode
new_date = datetime.today() + timedelta(days=15)
quant.with_user(self.demo_user).with_context(
inventory_mode=True).write({'removal_date': new_date})
self.assertEqual(quant.removal_date, new_date)
def test_approval_and_forecasted_qty(self):
"""
When a PO is waiting for an approval, its quantities should be included
in the draft quantity count
"""
self.env.company.po_double_validation = 'two_step'
self.env.company.po_double_validation_amount = 0
basic_purchase_user = mail_new_test_user(
self.env,
login='******',
groups='base.group_user,purchase.group_purchase_user',
)
po_form = Form(self.env['purchase.order'])
po_form.partner_id = self.partner
with po_form.order_line.new() as line:
line.product_id = self.product
line.product_qty = 50
po_form.save()
po_form = Form(self.env['purchase.order'])
po_form.partner_id = self.partner
with po_form.order_line.new() as line:
line.product_id = self.product
line.product_qty = 100
po = po_form.save()
po.with_user(basic_purchase_user).button_confirm()
docs = self.get_report_forecast(product_template_ids=self.product_template.ids)[1]
self.assertEqual(docs['draft_purchase_qty'], 150)
def setUpClass(cls):
super(TestChannelModeration, cls).setUpClass()
cls.channel = cls.env['mail.channel'].create({
'name':
'Moderation_1',
'channel_type':
'channel',
'email_send':
True,
'moderation':
True,
'channel_partner_ids': [(4, cls.partner_employee.id)],
'moderator_ids': [(4, cls.user_employee.id)],
'moderation_ids': [(0, 0, {
'email': '*****@*****.**',
'status': 'allow'
}), (0, 0, {
'email': '*****@*****.**',
'status': 'ban'
})],
})
cls.user_employee_2 = mail_new_test_user(
cls.env,
login='******',
groups='base.group_user',
company_id=cls.company_admin.id,
name='Enguerrand Employee2',
notification_type='inbox',
signature='--\nEnguerrand')
cls.partner_employee_2 = cls.user_employee_2.partner_id
cls.user_portal = cls._create_portal_user()
def setUpClass(cls):
super(TestChannelInternals, cls).setUpClass()
cls.test_channel = cls.env['mail.channel'].with_context(
cls._test_context).create({
'name': 'Test',
'channel_type': 'channel',
'email_send': False,
'description': 'Description',
'alias_name': 'test',
'public': 'public',
})
cls.test_partner = cls.env['res.partner'].with_context(
cls._test_context).create({
'name': 'Test Partner',
'email': '*****@*****.**',
})
cls.user_employee_nomail = mail_new_test_user(
cls.env,
login='******',
email=False,
groups='base.group_user',
company_id=cls.company_admin.id,
name='Evita Employee NoEmail',
notification_type='email',
signature='--\nEvite')
cls.partner_employee_nomail = cls.user_employee_nomail.partner_id
def setUpClass(cls):
super(TestPushNotification, cls).setUpClass()
sudo_icp = cls.env['ir.config_parameter'].sudo()
sudo_icp.set_param('odoo_ocn.project_id', 'Test')
sudo_icp.set_param('mail_mobile.enable_ocn', True)
channel = cls.env['mail.channel'].with_context(cls._test_context)
cls.user_email = cls.user_employee
cls.user_email.notification_type = 'email'
cls.user_email.partner_id.ocn_token = 'Test OCN Email'
cls.user_inbox = mail_new_test_user(cls.env,
login='******',
groups='base.group_user',
name='User Inbox',
notification_type='inbox')
cls.user_inbox.partner_id.ocn_token = 'Test OCN Inbox'
cls.record_simple = cls.env['mail.test.simple'].with_context(
cls._test_context).create({
'name': 'Test',
'email_from': '*****@*****.**'
})
cls.record_simple.message_subscribe(partner_ids=[
cls.user_email.partner_id.id,
cls.user_inbox.partner_id.id,
])
cls.direct_message_channel = channel.create({
'channel_partner_ids': [
(4, cls.user_email.partner_id.id),
(4, cls.user_inbox.partner_id.id),
],
'public':
'private',
'channel_type':
'chat',
'email_send':
False,
'name':
"Direct Message",
})
cls.group_channel = channel.create({
'channel_partner_ids': [
(4, cls.user_email.partner_id.id),
(4, cls.user_inbox.partner_id.id),
],
'public':
'public',
'email_send':
False,
'name':
'Channel',
})
cls.group_channel.message_subscribe(partner_ids=[
cls.user_email.partner_id.id,
cls.user_inbox.partner_id.id,
])
def setUp(self):
super(TestMailPluginControllerCommon, self).setUp()
self.user_test = mail_new_test_user(
self.env,
login="******",
groups="base.group_user,base.group_partner_manager",
)
def test_edit_quant_3(self):
""" Try to edit a record without the inventory mode.
Must raise an error.
"""
self.demo_user = mail_new_test_user(
self.env,
name='Pauline Poivraisselle',
login='******',
email='*****@*****.**',
groups='base.group_user',
)
user_admin = self.env.ref('base.user_admin')
quant = self.Quant.create({
'product_id': self.product.id,
'location_id': self.room1.id,
'quantity': 12
})
self.assertEqual(quant.quantity, 12)
# Try to write on quant without permission
with self.assertRaises(AccessError):
quant.with_user(self.demo_user).write({'inventory_quantity': 8})
self.assertEqual(quant.quantity, 12)
# Try to write on quant with permission
quant.with_user(user_admin).write({'inventory_quantity': 8})
quant.action_apply_inventory()
self.assertEqual(quant.quantity, 8)
def test_find_member_for_alias(self):
"""Test the matching of a mail_group.members, when 2 users have the same partner email, and
that the first user was subscribed."""
user = self.user_portal
user2 = mail_new_test_user(self.env, login='******', email=user.email)
member = self.env['mail.group.member'].create({
# subscribe with the first user
'partner_id':
user.partner_id.id,
'mail_group_id':
self.test_group.id,
})
self.assertEqual(member.email, user.email)
# In case of matching, function return a falsy value.
# Should not return string (exception) if at least one members have the same email, whatever
# the partner (author_id) that could match this email.
msg_dict = {
# send mail with the second user
'author_id': user2.partner_id.id,
'email_from': user2.email,
}
self.test_group.alias_id.alias_contact = 'followers'
self.assertFalse(
self.test_group._alias_get_error_message({}, msg_dict,
self.test_group.alias_id))
def setUpClass(cls):
super(TestActivityMixin, cls).setUpClass()
cls.user_utc = mail_new_test_user(
cls.env,
name='User UTC',
login='******',
)
cls.user_utc.tz = 'UTC'
cls.user_australia = mail_new_test_user(
cls.env,
name='user Australia',
login='******',
)
cls.user_australia.tz = 'Australia/ACT'
def setUpClass(cls):
super().setUpClass()
cls.partner_id = cls.env['res.partner'].create({'name': 'Wood Corner Partner'})
cls.product_id_1 = cls.env['product.product'].create({'name': 'Large Desk'})
cls.product_id_2 = cls.env['product.product'].create({'name': 'Conference Chair'})
cls.user_purchase_user = mail_new_test_user(
cls.env,
name='Pauline Poivraisselle',
login='******',
email='*****@*****.**',
notification_type='inbox',
groups='purchase.group_purchase_user',
)
cls.po_vals = {
'partner_id': cls.partner_id.id,
'order_line': [
(0, 0, {
'name': cls.product_id_1.name,
'product_id': cls.product_id_1.id,
'product_qty': 5.0,
'product_uom': cls.product_id_1.uom_po_id.id,
'price_unit': 500.0,
'date_planned': datetime.today().strftime(DEFAULT_SERVER_DATETIME_FORMAT),
})],
}
def setUp(self):
super(TestHrHolidaysCommon, self).setUp()
self.env.user.tz = 'Europe/Brussels'
# Test users to use through the various tests
self.user_hruser = mail_new_test_user(self.env, login='******', groups='base.group_user,hr_holidays.group_hr_holidays_user')
self.user_hruser_id = self.user_hruser.id
self.user_hrmanager = mail_new_test_user(self.env, login='******', groups='base.group_user,hr_holidays.group_hr_holidays_manager')
self.user_hrmanager_id = self.user_hrmanager.id
self.user_employee = mail_new_test_user(self.env, login='******', groups='base.group_user')
self.user_employee_id = self.user_employee.id
# Hr Data
Department = self.env['hr.department'].with_context(tracking_disable=True)
self.hr_dept = Department.create({
'name': 'Human Resources',
})
self.rd_dept = Department.create({
'name': 'Research and devlopment',
})
self.employee_emp = self.env['hr.employee'].create({
'name': 'David Employee',
'user_id': self.user_employee_id,
'department_id': self.rd_dept.id,
})
self.employee_emp_id = self.employee_emp.id
self.employee_hruser = self.env['hr.employee'].create({
'name': 'Armande HrUser',
'user_id': self.user_hruser_id,
'department_id': self.rd_dept.id,
})
self.employee_hruser_id = self.employee_hruser.id
self.employee_hrmanager = self.env['hr.employee'].create({
'name': 'Bastien HrManager',
'user_id': self.user_hrmanager_id,
'department_id': self.hr_dept.id,
'parent_id': self.employee_hruser_id,
})
self.employee_hrmanager_id = self.employee_hrmanager.id
self.rd_dept.write({'manager_id': self.employee_hruser_id})
def setUpClass(cls):
super(TestMailChannelMembers, cls).setUpClass()
cls.secret_group = cls.env['res.groups'].create({
'name': 'Secret User Group',
})
cls.env['ir.model.data'].create({
'name': 'secret_group',
'module': 'mail',
'model': cls.secret_group._name,
'res_id': cls.secret_group.id,
})
cls.user_1 = mail_new_test_user(
cls.env, login='******',
name='User 1',
groups='base.group_user,mail.secret_group')
cls.user_2 = mail_new_test_user(
cls.env, login='******',
name='User 2',
groups='base.group_user,mail.secret_group')
cls.user_portal = mail_new_test_user(
cls.env, login='******',
name='User Portal',
groups='base.group_portal')
cls.user_public = mail_new_test_user(
cls.env, login='******',
name='User Public',
groups='base.group_public')
cls.private_channel = cls.env['mail.channel'].create({
'name': 'Secret channel',
'public': 'private',
'channel_type': 'channel',
})
cls.group_channel = cls.env['mail.channel'].create({
'name': 'Group channel',
'public': 'groups',
'channel_type': 'channel',
'group_public_id': cls.secret_group.id,
})
cls.public_channel = cls.env['mail.channel'].create({
'name': 'Public channel of user 1',
'public': 'public',
'channel_type': 'channel',
})
(cls.private_channel | cls.group_channel | cls.public_channel).channel_last_seen_partner_ids.unlink()
