def setUpClass(cls):
super(TestMailResend, cls).setUpClass()
#Two users
cls.user1 = mail_new_test_user(cls.env, login='******', groups='base.group_public', name='Employee 1', email='e1') # invalid email
cls.user2 = mail_new_test_user(cls.env, login='******', groups='base.group_portal', name='Employee 2', email='*****@*****.**')
#Two partner
cls.partner1 = cls.env['res.partner'].with_context(common.BaseFunctionalTest._test_context).create({
'name': 'Partner 1',
'email': 'p1' # invalid email
})
cls.partner2 = cls.env['res.partner'].with_context(common.BaseFunctionalTest._test_context).create({
'name': 'Partner 2',
'email': '*****@*****.**'
})
@api.model
def send_email(self, message, *args, **kwargs):
assert '@' in message['To'], self.NO_VALID_RECIPIENT
return message['Message-Id']
cls.bus_update_failure = []
def sendone(self, channel, message):
if 'type' in message and message['type'] == 'mail_failure':
cls.bus_update_failure.append((channel, message))
cls.env['ir.mail_server']._patch_method('send_email', send_email)
cls.env['bus.bus']._patch_method('sendone', sendone)
cls.partners = cls.env['res.partner'].concat(cls.user1.partner_id, cls.user2.partner_id, cls.partner1, cls.partner2)
cls.invalid_email_partners = cls.env['res.partner'].concat(cls.user1.partner_id, cls.partner1)
def setUpClass(cls):
super(TestMailResend, cls).setUpClass()
cls.test_record = cls.env['mail.test.simple'].with_context(cls._test_context).create({'name': 'Test', 'email_from': '*****@*****.**'})
#Two users
cls.user1 = mail_new_test_user(cls.env, login='******', groups='base.group_public', name='Employee 1', email='e1') # invalid email
cls.user2 = mail_new_test_user(cls.env, login='******', groups='base.group_portal', name='Employee 2', email='*****@*****.**')
#Two partner
cls.partner1 = cls.env['res.partner'].with_context(cls._test_context).create({
'name': 'Partner 1',
'email': 'p1' # invalid email
})
cls.partner2 = cls.env['res.partner'].with_context(cls._test_context).create({
'name': 'Partner 2',
'email': '*****@*****.**'
})
@api.model
def send_email(self, message, *args, **kwargs):
assert '@' in message['To'], self.NO_VALID_RECIPIENT
return message['Message-Id']
cls.bus_update_failure = []
def sendone(self, channel, message):
if 'type' in message and message['type'] == 'mail_failure':
cls.bus_update_failure.append((channel, message))
cls.env['ir.mail_server']._patch_method('send_email', send_email)
cls.env['bus.bus']._patch_method('sendone', sendone)
cls.partners = cls.env['res.partner'].concat(cls.user1.partner_id, cls.user2.partner_id, cls.partner1, cls.partner2)
cls.invalid_email_partners = cls.env['res.partner'].concat(cls.user1.partner_id, cls.partner1)
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(common.BaseFunctionalTest._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 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(TestChannelAccessRights, cls).setUpClass()
Channel = cls.env['mail.channel'].with_context(
common.BaseFunctionalTest._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_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 group
cls.group_private = Channel.create({
'name': 'Private',
'public': 'private'
})
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 setUp(self):
super(TestHrHolidaysBase, self).setUp()
# 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
self.user_hrmanager_2 = mail_new_test_user(self.env, login='******', groups='base.group_user,hr_holidays.group_hr_holidays_manager')
self.user_hrmanager_2_id = self.user_hrmanager_2.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,
})
self.employee_hrmanager_id = self.employee_hrmanager.id
self.employee_hrmanager_2_id = self.env['hr.employee'].create({
'name': 'Florence HrManager',
'user_id': self.user_hrmanager_2_id,
'parent_id': self.employee_hrmanager_id,
}).id
self.rd_dept.write({'manager_id': self.employee_hruser_id})
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 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_dmfa(self):
user = mail_new_test_user(
self.env,
login='******',
groups=
'hr_payroll.group_hr_payroll_manager,fleet.fleet_group_manager')
lap = self.env.ref('hr_contract_salary.hr_employee_laurie_poiret')
company = lap.company_id
user.company_ids = [(4, company.id)]
today = date.today()
lap.address_id = lap.company_id.partner_id
company.dmfa_employer_class = 456
company.onss_registration_number = 45645
company.onss_company_id = 45645
self.env['l10n_be.dmfa.location.unit'].with_user(user).create({
'company_id':
lap.company_id.id,
'code':
123,
'partner_id':
lap.address_id.id,
})
dmfa = self.env['l10n_be.dmfa'].with_user(user).create({
'reference':
'TESTDMFA',
'company_id':
self.env.ref('l10n_be_hr_payroll.res_company_be').id
})
dmfa.generate_dmfa_report()
self.assertFalse(dmfa.error_message)
self.assertEqual(dmfa.validation_state, 'done')
def test_body_responsive(self):
""" Testing mail mailing responsive mail body """
test_user = mail_new_test_user(
self.env, login='******',
groups='mass_mailing.group_mass_mailing_user,base.group_partner_manager' # TDE FIXME: check if really necessary for mass mailing
)
test_record = self.env['res.partner'].create({'name': 'Mass Mail Partner'})
mass_mail_record = self.env['mailing.mailing'].with_user(test_user).create({
'name': 'Test',
'subject': 'Test',
'state': 'draft',
'mailing_model_id': self.env.ref('base.model_res_partner').id,
})
composer = self.env['mail.compose.message'].with_user(test_user).with_context({
'default_composition_mode': 'mass_mail',
'default_model': 'res.partner',
'default_res_id': test_record.id,
}).create({
'subject': 'Mass Mail Responsive',
'body': 'I am Responsive body',
'mass_mailing_id': mass_mail_record.id
})
mail_values = composer.get_mail_values([test_record.id])
body_html = str(mail_values[test_record.id]['body_html'])
self.assertIn('<!DOCTYPE html>', body_html)
self.assertIn('<head>', body_html)
self.assertIn('viewport', body_html)
self.assertIn('@media', body_html)
self.assertIn('I am Responsive body', body_html)
def test_body_responsive(self):
""" Testing mail mailing responsive mail body """
test_user = mail_new_test_user(
self.env, login='******',
groups='mass_mailing.group_mass_mailing_user,base.group_partner_manager' # TDE FIXME: check if really necessary for mass mailing
)
test_record = self.env['res.partner'].create({'name': 'Mass Mail Partner'})
mass_mail_record = self.env['mail.mass_mailing'].sudo(test_user).create({
'name': 'Test',
'state': 'draft',
'mailing_model_id': self.env.ref('base.model_res_partner').id,
})
composer = self.env['mail.compose.message'].sudo(test_user).with_context({
'default_composition_mode': 'mass_mail',
'default_model': 'res.partner',
'default_res_id': test_record.id,
}).create({
'subject': 'Mass Mail Responsive',
'body': 'I am Responsive body',
'mass_mailing_id': mass_mail_record.id
})
mail_values = composer.get_mail_values([test_record.id])
body_html = str(mail_values[test_record.id]['body_html'])
self.assertIn('<!DOCTYPE html>', body_html)
self.assertIn('<head>', body_html)
self.assertIn('viewport', body_html)
self.assertIn('@media', body_html)
self.assertIn('I am Responsive body', body_html)
def test_message_process_create_uid_email_follower(self):
self.alias.write({
'alias_parent_model_id': self.test_model.id,
'alias_parent_thread_id': self.test_record.id,
})
follower_user = mail_new_test_user(self.env,
login='******',
groups='base.group_user',
name='Ernest Follower',
email=self.user_employee.email)
self.test_record.message_subscribe(follower_user.partner_id.ids)
record = self.format_and_process(MAIL_TEMPLATE,
self.user_employee.email_formatted,
'*****@*****.**',
subject='FollowerWinner')
self.assertEqual(record.create_uid, follower_user)
self.assertEqual(record.message_ids[0].subject, 'FollowerWinner')
self.assertEqual(record.message_ids[0].create_uid, follower_user)
self.assertEqual(record.message_ids[0].author_id,
follower_user.partner_id)
# name order win
self.test_record.message_unsubscribe(follower_user.partner_id.ids)
record = self.format_and_process(MAIL_TEMPLATE,
self.user_employee.email_formatted,
'*****@*****.**',
subject='FirstFoundWinner')
self.assertEqual(record.create_uid, self.user_employee)
self.assertEqual(record.message_ids[0].subject, 'FirstFoundWinner')
self.assertEqual(record.message_ids[0].create_uid, self.user_employee)
self.assertEqual(record.message_ids[0].author_id,
self.user_employee.partner_id)
def setUp(self):
super().setUp()
self.model = self.env[self.model_name]
u = mail_new_test_user(
self.env,
login='******',
password='******',
groups='base.group_user,base.group_allow_export')
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 test_post_portal_crash(self):
portal_user = mail_new_test_user(self.env, login='******', groups='base.group_portal', name='Chell Gladys')
with self.assertRaises(AccessError):
self.test_record.sudo(portal_user).message_post(
body='<p>Test</p>', subject='Subject',
message_type='comment', subtype='mt_comment')
def setUpClass(cls):
super(AdvancedFollowersTest, cls).setUpClass()
cls.user_portal = mail_new_test_user(cls.env, login='******', groups='base.group_portal', name='Chell Gladys')
cls.test_track = cls.env['mail.test.track'].sudo(cls.user_employee).create({
'name': 'Test',
})
Subtype = cls.env['mail.message.subtype']
# clean demo data to avoid interferences
Subtype.search([('res_model', 'in', ['mail.test', 'mail.test.track'])]).unlink()
cls.sub_nodef = Subtype.create({'name': 'Sub NoDefault', 'default': False, 'res_model': 'mail.test'})
cls.sub_umb1 = Subtype.create({'name': 'Sub Umbrella1', 'default': False, 'res_model': 'mail.test.track'})
cls.sub_umb2 = Subtype.create({'name': 'Sub Umbrella2', 'default': False, 'res_model': 'mail.test.track'})
cls.umb_def = Subtype.create({'name': 'Umbrella Default', 'default': True, 'res_model': 'mail.test'})
# create subtypes for auto subscription from umbrella to sub records
cls.umb_sub_def = Subtype.create({
'name': 'Umbrella Sub1', 'default': True, 'res_model': 'mail.test',
'parent_id': cls.sub_umb1.id, 'relation_field': 'umbrella_id'})
cls.umb_sub_nodef = Subtype.create({
'name': 'Umbrella Sub2', 'default': False, 'res_model': 'mail.test',
'parent_id': cls.sub_umb2.id, 'relation_field': 'umbrella_id'})
def test_message_compose_portal_ok(self):
portal_user = mail_new_test_user(self.env, login='******', groups='base.group_portal', name='Chell Gladys')
with patch.object(MailTestSimple, 'check_access_rights', return_value=True):
ComposerPortal = self.env['mail.compose.message'].sudo(portal_user)
ComposerPortal.with_context({
'default_composition_mode': 'comment',
'default_model': self.test_record._name,
'default_res_id': self.test_record.id,
}).create({
'subject': 'Subject',
'body': '<p>Body text</p>',
'partner_ids': []}).send_mail()
self.assertEqual(self.test_record.message_ids[0].body, '<p>Body text</p>')
self.assertEqual(self.test_record.message_ids[0].author_id, portal_user.partner_id)
ComposerPortal.with_context({
'default_composition_mode': 'comment',
'default_parent_id': self.test_record.message_ids.ids[0],
}).create({
'subject': 'Subject',
'body': '<p>Body text 2</p>'}).send_mail()
self.assertEqual(self.test_record.message_ids[0].body, '<p>Body text 2</p>')
self.assertEqual(self.test_record.message_ids[0].author_id, portal_user.partner_id)
def test_access_rights_user(self):
# Administration/Settings
user = mail_new_test_user(self.env,
login='******',
groups='base.group_user')
with self.assertRaises(AccessError):
self.env['alsw.sparkpost.config'].sudo(user.id).create(
self.default_sparkpost())
def setUpClass(cls):
super(MassSMSBaseFunctionalTest, cls).setUpClass()
cls.user_marketing = mail_new_test_user(
cls.env,
login='******',
groups='base.group_user,mass_mailing.group_mass_mailing_user',
name='Martial Marketing',
signature='--\nMartial')
def test_set_message_done_portal(self):
user_portal = mail_new_test_user(self.env, login='******', groups='base.group_portal', name='Chell Gladys', notification_type='inbox')
self.partner_portal = user_portal.partner_id
with self.assertNotifications(partner_employee=(1, 'inbox', 'unread'), partner_portal=(1, 'inbox', 'read')):
message = self.test_record.message_post(
body='Test', message_type='comment', subtype='mail.mt_comment',
partner_ids=[self.user_employee.partner_id.id, user_portal.partner_id.id])
message.with_user(user_portal).set_message_done()
def setUp(self):
super(EventSaleTest, self).setUp()
self.EventRegistration = self.env['event.registration']
# First I create an event product
product = self.env['product.product'].create({
'name': 'test_formation',
'type': 'service',
'event_ok': True,
})
# I create an event from the same type than my product
self.event = self.env['event.event'].create({
'name': 'test_event',
'event_type_id': 1,
'date_end': '2012-01-01 19:05:15',
'date_begin': '2012-01-01 18:05:15'
})
ticket = self.env['event.event.ticket'].create({
'name': 'test_ticket',
'product_id': product.id,
'event_id': self.event.id,
})
self.user_salesperson = mail_new_test_user(self.env, login='******', groups='sales_team.group_sale_salesman')
# I create a sales order
self.sale_order = self.env['sale.order'].create({
'partner_id': self.env.ref('base.res_partner_2').id,
'note': 'Invoice after delivery',
'payment_term_id': self.env.ref('account.account_payment_term').id
})
# In the sales order I add some sales order lines. i choose event product
self.env['sale.order.line'].create({
'product_id': product.id,
'price_unit': 190.50,
'product_uom': self.env.ref('uom.product_uom_unit').id,
'product_uom_qty': 8.0,
'order_id': self.sale_order.id,
'name': 'sales order line',
'event_id': self.event.id,
'event_ticket_id': ticket.id,
})
# In the event registration I add some attendee detail lines. i choose event product
self.register_person = self.env['registration.editor'].create({
'sale_order_id': self.sale_order.id,
'event_registration_ids': [(0, 0, {
'event_id': self.event.id,
'name': 'Administrator',
'email': '*****@*****.**',
'sale_order_line_id': self.sale_order.order_line.id,
})],
})
def setUp(self):
super(TestHrCommon, self).setUp()
self.res_users_hr_officer = mail_new_test_user(
self.env,
login='******',
groups='base.group_user,hr.group_hr_user',
name='HR Officer',
email='*****@*****.**')
def create_user_employee(self, login, groups):
user = mail_new_test_user(self.env, login=login, groups=groups)
user.company_id.country_id = self.env.ref('base.be')
employee = self.env['hr.employee'].create({
'name': 'Employee %s' % login,
'user_id': user.id,
})
user.tz = employee.tz
return user
def test_set_message_done_portal(self):
user_portal = mail_new_test_user(self.env, login='******', groups='base.group_portal', name='Chell Gladys', notification_type='inbox')
self.partner_portal = user_portal.partner_id
with self.assertNotifications(partner_employee=(1, 'inbox', 'unread'), partner_portal=(1, 'inbox', 'read')):
message = self.test_record.message_post(
body='Test', message_type='comment', subtype='mail.mt_comment',
partner_ids=[self.user_employee.partner_id.id, user_portal.partner_id.id])
message.sudo(user_portal).set_message_done()
def setUpClass(cls):
super().setUpClass()
cls.user_admin = mail_new_test_user(cls.env,
login='******',
groups='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)
def test_followers_subtypes_default_internal(self):
user_portal = mail_new_test_user(self.env, login='******', groups='base.group_portal', name='Chell Gladys')
test_record = self.test_record.sudo(self.user_employee)
test_record.message_subscribe(partner_ids=[user_portal.partner_id.id])
self.assertEqual(test_record.message_partner_ids, user_portal.partner_id)
follower = self.env['mail.followers'].search([
('res_model', '=', 'mail.test.simple'),
('res_id', '=', test_record.id),
('partner_id', '=', user_portal.partner_id.id)])
self.assertEqual(follower.subtype_ids, self.default_group_subtypes_portal)
def test_post_portal_ok(self):
portal_user = mail_new_test_user(self.env, login='******', groups='base.group_portal', name='Chell Gladys')
with patch.object(MailTestSimple, 'check_access_rights', return_value=True):
self.test_record.message_subscribe((self.partner_1 | self.user_employee.partner_id).ids)
new_msg = self.test_record.sudo(portal_user).message_post(
body='<p>Test</p>', subject='Subject',
message_type='comment', subtype='mt_comment')
self.assertEqual(new_msg.sudo().needaction_partner_ids, (self.partner_1 | self.user_employee.partner_id))
self.assertEmails(portal_user.partner_id, [[self.partner_1], [self.user_employee.partner_id]])
def test_activity_flow_portal(self):
portal_user = mail_new_test_user(self.env, login='******', groups='base.group_portal', name='Chell Gladys')
with self.sudoAs('chell'):
test_record = self.env['mail.test.activity'].browse(self.test_record.id)
with self.assertRaises(exceptions.AccessError):
self.env['mail.activity'].create({
'summary': 'Test Activity',
'activity_type_id': self.env.ref('mail.mail_activity_data_email').id,
'res_model_id': self.env['ir.model']._get(test_record._name).id,
'res_id': test_record.id,
})
def setUpClass(cls):
super(MassMailingCase, cls).setUpClass()
# be sure for some common data
cls.user_employee.write({
'login': '******',
})
cls.user_marketing = mail_new_test_user(
cls.env, login='******',
groups='base.group_user,mass_mailing.group_mass_mailing_user',
name='Martial Marketing', signature='--\nMartial')
def setUp(self):
super(TestBLAccessRights, self).setUp()
self.bl_rec = self.env['mail.blacklist'].create([
{
'email': 'Not A Stark <*****@*****.**>'
},
])
self.user_portal = mail_new_test_user(self.env,
login='******',
groups='base.group_portal')
self.bl_previous = self.env['mail.blacklist'].search([])
def setUpClass(cls):
super(MassMailingCase, cls).setUpClass()
# be sure for some common data
cls.user_employee.write({
'login': '******',
})
cls.user_marketing = mail_new_test_user(
cls.env,
login='******',
groups='base.group_user,mass_mailing.group_mass_mailing_user',
name='Martial Marketing',
signature='--\nMartial')
def test_ui(self):
# no user available for belgian company so to set hr responsible change company of demo
demo = mail_new_test_user(self.env,
name="Laurie Poiret",
login='******',
groups='base.group_user')
partner_id = self.env.ref(
'hr_contract_salary.res_partner_laurie_poiret').id
company_id = self.env.ref('l10n_be_hr_payroll.res_company_be').id
demo.write({
'partner_id': partner_id,
'company_id': company_id,
'company_ids': [(4, company_id)]
})
self.start_tour("/",
'hr_contract_salary_tour',
login='******',
timeout=100)
def test_message_process_partner_find(self):
""" Finding the partner based on email, based on partner / user / follower """
self.alias.write({'alias_force_thread_id': self.test_record.id})
from_1 = self.env['res.partner'].create({
'name':
'Brice Denisse',
'email':
'*****@*****.**'
})
self.format_and_process(
MAIL_TEMPLATE,
msg_id='<1>',
email_from='Brice Denisse <*****@*****.**>')
self.assertEqual(self.test_record.message_ids[0].author_id, from_1)
self.test_record.message_unsubscribe([from_1.id])
from_2 = mail_new_test_user(self.env,
login='******',
groups='base.group_user',
name='Brice Denisse',
email='*****@*****.**')
self.format_and_process(
MAIL_TEMPLATE,
msg_id='<2>',
email_from='Brice Denisse <*****@*****.**>')
self.assertEqual(self.test_record.message_ids[0].author_id,
from_2.partner_id)
self.test_record.message_unsubscribe([from_2.partner_id.id])
from_3 = self.env['res.partner'].create({
'name':
'Brice Denisse',
'email':
'*****@*****.**'
})
self.test_record.message_subscribe([from_3.id])
self.format_and_process(
MAIL_TEMPLATE,
msg_id='<3>',
email_from='Brice Denisse <*****@*****.**>')
self.assertEqual(self.test_record.message_ids[0].author_id, from_3)
def test_message_process_partner_find(self):
""" Finding the partner based on email, based on partner / user / follower """
self.alias.write({'alias_force_thread_id': self.test_record.id})
from_1 = self.env['res.partner'].create({'name': 'Brice Denisse', 'email': '*****@*****.**'})
self.format_and_process(MAIL_TEMPLATE, from_1.email_formatted, '*****@*****.**')
self.assertEqual(self.test_record.message_ids[0].author_id, from_1)
self.test_record.message_unsubscribe([from_1.id])
from_2 = mail_new_test_user(self.env, login='******', groups='base.group_user', name='User Denisse', email='*****@*****.**')
self.format_and_process(MAIL_TEMPLATE, from_1.email_formatted, '*****@*****.**')
self.assertEqual(self.test_record.message_ids[0].author_id, from_2.partner_id)
self.test_record.message_unsubscribe([from_2.partner_id.id])
from_3 = self.env['res.partner'].create({'name': 'FOllower Denisse', 'email': '*****@*****.**'})
self.test_record.message_subscribe([from_3.id])
self.format_and_process(MAIL_TEMPLATE, from_1.email_formatted, '*****@*****.**')
self.assertEqual(self.test_record.message_ids[0].author_id, from_3)
def test_access_rights_as(self):
# Administration/Settings
user = mail_new_test_user(self.env,
login='******',
groups='base.group_system')
config = self.env['alsw.sparkpost.config'].sudo(user.id).create(
self.default_sparkpost())
self.assertEqual(config.name, 'Test')
#
config.get_access_token()
#
raw = config.username + config.password
duplicate = hashlib.md5(raw.encode("utf-8")).hexdigest()
self.assertEqual(config.duplicate, duplicate)
#
smtp = config.create_smtp()
self.assertEqual(smtp.name, 'Sparkpost SMTP')
#
smtp.unlink()
config.unlink()
def _activate_multi_company(cls):
""" Create another company, add it to admin and create an user that
belongs to that new company. It allows to test flows with users from
different companies. """
cls.company_2 = cls.env['res.company'].create({
'name':
'Company 2',
'email':
'*****@*****.**',
})
cls.user_admin.write({'company_ids': [(4, cls.company_2.id)]})
cls.user_employee_c2 = mail_new_test_user(
cls.env,
login='******',
company_id=cls.company_2.id,
company_ids=[(4, cls.company_2.id)],
groups='base.group_user',
name='Enguerrand Employee C2',
notification_type='inbox',
signature='--\nEnguerrand')
cls.partner_employee_c2 = cls.user_employee_c2.partner_id
from odoo.addons.test_mail.tests.common import mail_new_test_user
class XlsxCreatorCase(common.HttpCase):
model_name = False
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.model = None
def setUp(self):
super().setUp()
self.model = self.env[self.model_name]
<<<<<<< HEAD
mail_new_test_user(self.env, login='******', password='******')
=======
u = mail_new_test_user(self.env, login='******', password='******', groups='base.group_user,base.group_allow_export')
>>>>>>> f0a66d05e70e432d35dc68c9fb1e1cc6e51b40b8
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(TestHrCommon, self).setUp()
self.res_users_hr_officer = mail_new_test_user(self.env, login='******', groups='base.group_user,hr.group_hr_user', name='HR Officer', email='*****@*****.**')
