def test_edit_task_in_project_sharing(self):
""" Test when portal user creates a task in project sharing views.
Test Cases:
==========
1) Give the 'read' access mode to a portal user in a project and try to edit task with this user.
2) Give the 'comment' access mode to a portal user in a project and try to edit task with this user.
3) Give the 'edit' access mode to a portal user in a project and try to create task with this user.
3.1) Try to change the project of the new task with this user.
3.2) Create a sub-task
3.3) Create a second sub-task
"""
# 1) Give the 'read' access mode to a portal user in a project and try to create task with this user.
with self.assertRaises(AccessError, msg="Should not accept the portal user create a task in the project when he has not the edit access right."):
with self.get_project_sharing_form_view(self.task_cow.with_context({'tracking_disable': True, 'default_project_id': self.project_cows.id}), self.user_portal) as form:
form.name = 'Test'
task = form.save()
project_share_wizard = self.env['project.share.wizard'].create({
'access_mode': 'edit',
'res_model': 'project.project',
'res_id': self.project_cows.id,
'partner_ids': [
Command.link(self.user_portal.partner_id.id),
],
})
project_share_wizard.action_send_mail()
with self.get_project_sharing_form_view(self.task_cow.with_context({'tracking_disable': True, 'default_project_id': self.project_cows.id, 'uid': self.user_portal.id}), self.user_portal) as form:
form.name = 'Test'
task = form.save()
self.assertEqual(task.name, 'Test')
self.assertEqual(task.project_id, self.project_cows)
# 3.1) Try to change the project of the new task with this user.
with self.assertRaises(AssertionError, msg="Should not accept the portal user changes the project of the task."):
with self.get_project_sharing_form_view(task, self.user_portal) as form:
form.project_id = self.project_portal
# 3.2) Create a sub-task
with self.get_project_sharing_form_view(task, self.user_portal) as form:
with form.child_ids.new() as subtask_form:
subtask_form.name = 'Test Subtask'
with self.assertRaises(AssertionError, msg="Should not accept the portal user changes the project of the task."):
subtask_form.display_project_id = self.project_portal
self.assertEqual(task.child_ids.name, 'Test Subtask')
self.assertEqual(task.child_ids.project_id, self.project_cows)
self.assertFalse(task.child_ids.portal_user_names, 'by default no user should be assigned to a subtask created by the portal user.')
self.assertFalse(task.child_ids.user_ids, 'No user should be assigned to the new subtask.')
task2 = self.env['project.task'] \
.with_context({
'tracking_disable': True,
'default_project_id': self.project_cows.id,
'default_user_ids': [Command.set(self.user_portal.ids)],
}) \
.with_user(self.user_portal) \
.create({'name': 'Test'})
self.assertFalse(task2.portal_user_names, 'the portal user should not be assigned when the portal user creates a task into the project shared.')
# 3.3) Create a second sub-task
with self.get_project_sharing_form_view(task, self.user_portal) as form:
with form.child_ids.new() as subtask_form:
subtask_form.name = 'Test Subtask'
self.assertEqual(len(task.child_ids), 2, 'Check 2 subtasks has correctly been created by the user portal.')
def test_implied_groups(self):
""" We check that the adding of implied ids works correctly for normal users and portal users.
In the second case, working normally means raising if a group implies to give 'group_user'
rights to a portal user.
"""
U = self.env["res.users"]
G = self.env["res.groups"]
group_user = self.env.ref('base.group_user')
group_portal = self.env.ref('base.group_portal')
group_no_one = self.env.ref('base.group_no_one')
group_A = G.create({"name": "A"})
group_AA = G.create({
"name": "AA",
"implied_ids": [Command.set([group_A.id])]
})
group_B = G.create({"name": "B"})
group_BB = G.create({
"name": "BB",
"implied_ids": [Command.set([group_B.id])]
})
# user_a is a normal user, so we expect groups to be added when we add them,
# as well as 'implied_groups'; otherwise nothing else should happen.
# By contrast, for a portal user we want implied groups not to be added
# if and only if it would not give group_user (or group_public) privileges
user_a = U.create({
"name":
"a",
"login":
"******",
"groups_id": [Command.set([group_AA.id, group_user.id])]
})
self.assertEqual(user_a.groups_id,
(group_AA + group_A + group_user + group_no_one))
user_b = U.create({
"name":
"b",
"login":
"******",
"groups_id": [Command.set([group_portal.id, group_AA.id])]
})
self.assertEqual(user_b.groups_id, (group_AA + group_A + group_portal))
# user_b is not an internal user, but giving it a new group just added a new group
(user_a + user_b).write({"groups_id": [Command.link(group_BB.id)]})
self.assertEqual(user_a.groups_id,
(group_AA + group_A + group_BB + group_B +
group_user + group_no_one))
self.assertEqual(
user_b.groups_id,
(group_AA + group_A + group_BB + group_B + group_portal))
# now we create a group that implies the group_user
# adding it to a user should work normally, whereas adding it to a portal user should raise
group_C = G.create({
"name": "C",
"implied_ids": [Command.set([group_user.id])]
})
user_a.write({"groups_id": [Command.link(group_C.id)]})
self.assertEqual(user_a.groups_id,
(group_AA + group_A + group_BB + group_B + group_C +
group_user + group_no_one))
with self.assertRaises(ValidationError):
user_b.write({"groups_id": [Command.link(group_C.id)]})
def test_sudo(self):
record = self.env['test_access_right.some_obj'].create({'val': 5})
user1 = self.user
partner_demo = self.env['res.partner'].create({
'name': 'Marc Demo',
})
user2 = self.env['res.users'].create({
'login':
'******',
'password':
'******',
'partner_id':
partner_demo.id,
'groups_id': [
Command.set([
self.env.ref('base.group_user').id,
self.env.ref('base.group_partner_manager').id
])
],
})
# with_user(user)
record1 = record.with_user(user1)
self.assertEqual(record1.env.uid, user1.id)
self.assertFalse(record1.env.su)
record2 = record1.with_user(user2)
self.assertEqual(record2.env.uid, user2.id)
self.assertFalse(record2.env.su)
# the superuser is always in superuser mode
record3 = record2.with_user(SUPERUSER_ID)
self.assertEqual(record3.env.uid, SUPERUSER_ID)
self.assertTrue(record3.env.su)
# sudo()
surecord1 = record1.sudo()
self.assertEqual(surecord1.env.uid, user1.id)
self.assertTrue(surecord1.env.su)
surecord2 = record2.sudo()
self.assertEqual(surecord2.env.uid, user2.id)
self.assertTrue(surecord2.env.su)
surecord3 = record3.sudo()
self.assertEqual(surecord3.env.uid, SUPERUSER_ID)
self.assertTrue(surecord3.env.su)
# sudo().sudo()
surecord1 = surecord1.sudo()
self.assertEqual(surecord1.env.uid, user1.id)
self.assertTrue(surecord1.env.su)
# sudo(False)
record1 = surecord1.sudo(False)
self.assertEqual(record1.env.uid, user1.id)
self.assertFalse(record1.env.su)
record2 = surecord2.sudo(False)
self.assertEqual(record2.env.uid, user2.id)
self.assertFalse(record2.env.su)
record3 = surecord3.sudo(False)
self.assertEqual(record3.env.uid, SUPERUSER_ID)
self.assertTrue(record3.env.su)
# sudo().with_user(user)
record2 = surecord1.with_user(user2)
self.assertEqual(record2.env.uid, user2.id)
self.assertFalse(record2.env.su)
def test_zero_amount_tax(self):
""" Ensure the tax details is generated for 0% tax. """
zero_tax = self.env['account.tax'].create({
'name': "zero_tax",
'amount_type': 'percent',
'amount': 0.0,
})
invoice = self.env['account.move'].create({
'move_type':
'out_invoice',
'partner_id':
self.partner_a.id,
'invoice_date':
'2019-01-01',
'invoice_line_ids': [
Command.create({
'name':
'line1',
'account_id':
self.company_data['default_account_revenue'].id,
'price_unit':
1000.0,
'tax_ids': [Command.set(zero_tax.ids)],
}),
Command.create({
'name':
'line2',
'account_id':
self.company_data['default_account_revenue'].id,
'price_unit':
1000.0,
'tax_ids': [Command.set(zero_tax.ids)],
}),
]
})
base_lines, tax_lines = self._dispatch_move_lines(invoice)
tax_details = self._get_tax_details()
self.assertTaxDetailsValues(
tax_details,
[
{
'base_line_id': base_lines[0].id,
'tax_line_id': tax_lines[0].id,
'base_amount': -1000.0,
'tax_amount': 0.0,
},
{
'base_line_id': base_lines[1].id,
'tax_line_id': tax_lines[0].id,
'base_amount': -1000.0,
'tax_amount': 0.0,
},
],
)
self.assertTotalAmounts(invoice, tax_details)
# Same with a group of taxes
tax_group = self.env['account.tax'].create({
'name':
"tax_group",
'amount_type':
'group',
'children_tax_ids': [Command.set(zero_tax.ids)],
})
invoice.write({
'invoice_line_ids': [
Command.update(base_lines[0].id,
{'tax_ids': [Command.set(tax_group.ids)]}),
Command.update(base_lines[1].id,
{'tax_ids': [Command.set(tax_group.ids)]}),
],
})
base_lines, tax_lines = self._dispatch_move_lines(invoice)
tax_details = self._get_tax_details()
self.assertTaxDetailsValues(
tax_details,
[
{
'base_line_id': base_lines[0].id,
'tax_line_id': tax_lines[0].id,
'base_amount': -1000.0,
'tax_amount': 0.0,
},
{
'base_line_id': base_lines[1].id,
'tax_line_id': tax_lines[0].id,
'base_amount': -1000.0,
'tax_amount': 0.0,
},
],
)
self.assertTotalAmounts(invoice, tax_details)
def test_partitioning_lines_by_moves(self):
tax_20_affect = self.env['account.tax'].create({
'name':
"tax_20_affect",
'amount_type':
'percent',
'amount':
20.0,
'include_base_amount':
True,
})
tax_10 = self.env['account.tax'].create({
'name': "tax_10",
'amount_type': 'percent',
'amount': 10.0,
})
invoices = self.env['account.move']
expected_values_list = []
for i in range(1, 6):
invoice = invoices.create({
'move_type':
'out_invoice',
'partner_id':
self.partner_a.id,
'invoice_date':
'2019-01-01',
'invoice_line_ids': [
Command.create({
'name':
'line1',
'account_id':
self.company_data['default_account_revenue'].id,
'price_unit':
i * 1000.0,
'tax_ids': [Command.set((tax_20_affect + tax_10).ids)],
}),
]
})
invoices |= invoice
base_lines, tax_lines = self._dispatch_move_lines(invoice)
expected_values_list += [
{
'base_line_id': base_lines[0].id,
'tax_line_id': tax_lines[1].id,
'base_amount': -200.0 * i,
'tax_amount': -20.0 * i,
},
{
'base_line_id': base_lines[0].id,
'tax_line_id': tax_lines[1].id,
'base_amount': -1000.0 * i,
'tax_amount': -100.0 * i,
},
{
'base_line_id': base_lines[0].id,
'tax_line_id': tax_lines[0].id,
'base_amount': -1000.0 * i,
'tax_amount': -200.0 * i,
},
]
tax_details = self._get_tax_details()
self.assertTaxDetailsValues(tax_details, expected_values_list)
self.assertTotalAmounts(invoices, tax_details)
def test_write_base_many2many(self):
""" Write on many2many field. """
rec1 = self.env['test_performance.base'].create({'name': 'X'})
# create N tags on rec1: O(N) queries
with self.assertQueryCount(4):
self.env.invalidate_all()
rec1.write({'tag_ids': [Command.create({'name': 0})]})
self.assertEqual(len(rec1.tag_ids), 1)
with self.assertQueryCount(4):
self.env.invalidate_all()
rec1.write({'tag_ids': [Command.create({'name': val}) for val in range(1, 12)]})
self.assertEqual(len(rec1.tag_ids), 12)
tags = rec1.tag_ids
# update N tags: O(N) queries
with self.assertQueryCount(3):
self.env.invalidate_all()
rec1.write({'tag_ids': [Command.update(tag.id, {'name': 'X'}) for tag in tags[0]]})
self.assertEqual(rec1.tag_ids, tags)
with self.assertQueryCount(3):
self.env.invalidate_all()
rec1.write({'tag_ids': [Command.update(tag.id, {'name': 'X'}) for tag in tags[1:]]})
self.assertEqual(rec1.tag_ids, tags)
# delete N tags: O(1) queries
with self.assertQueryCount(__system__=8, demo=8):
self.env.invalidate_all()
rec1.write({'tag_ids': [Command.delete(tag.id) for tag in tags[0]]})
self.assertEqual(rec1.tag_ids, tags[1:])
with self.assertQueryCount(__system__=8, demo=8):
self.env.invalidate_all()
rec1.write({'tag_ids': [Command.delete(tag.id) for tag in tags[1:]]})
self.assertFalse(rec1.tag_ids)
self.assertFalse(tags.exists())
rec1.write({'tag_ids': [Command.create({'name': val}) for val in range(12)]})
tags = rec1.tag_ids
# unlink N tags: O(1) queries
with self.assertQueryCount(3):
self.env.invalidate_all()
rec1.write({'tag_ids': [Command.unlink(tag.id) for tag in tags[0]]})
self.assertEqual(rec1.tag_ids, tags[1:])
with self.assertQueryCount(3):
self.env.invalidate_all()
rec1.write({'tag_ids': [Command.unlink(tag.id) for tag in tags[1:]]})
self.assertFalse(rec1.tag_ids)
self.assertTrue(tags.exists())
rec2 = self.env['test_performance.base'].create({'name': 'X'})
# link N tags from rec1 to rec2: O(1) queries
with self.assertQueryCount(3):
self.env.invalidate_all()
rec2.write({'tag_ids': [Command.link(tag.id) for tag in tags[0]]})
self.assertEqual(rec2.tag_ids, tags[0])
with self.assertQueryCount(3):
self.env.invalidate_all()
rec2.write({'tag_ids': [Command.link(tag.id) for tag in tags[1:]]})
self.assertEqual(rec2.tag_ids, tags)
with self.assertQueryCount(2):
self.env.invalidate_all()
rec2.write({'tag_ids': [Command.link(tag.id) for tag in tags[1:]]})
self.assertEqual(rec2.tag_ids, tags)
# empty N tags in rec2: O(1) queries
with self.assertQueryCount(3):
self.env.invalidate_all()
rec2.write({'tag_ids': [Command.clear()]})
self.assertFalse(rec2.tag_ids)
self.assertTrue(tags.exists())
with self.assertQueryCount(2):
self.env.invalidate_all()
rec2.write({'tag_ids': [Command.clear()]})
self.assertFalse(rec2.tag_ids)
# set N tags in rec2: O(1) queries
with self.assertQueryCount(3):
self.env.invalidate_all()
rec2.write({'tag_ids': [Command.set(tags.ids)]})
self.assertEqual(rec2.tag_ids, tags)
with self.assertQueryCount(3):
self.env.invalidate_all()
rec2.write({'tag_ids': [Command.set(tags[:8].ids)]})
self.assertEqual(rec2.tag_ids, tags[:8])
with self.assertQueryCount(4):
self.env.invalidate_all()
rec2.write({'tag_ids': [Command.set(tags[4:].ids)]})
self.assertEqual(rec2.tag_ids, tags[4:])
with self.assertQueryCount(3):
self.env.invalidate_all()
rec2.write({'tag_ids': [Command.set(tags.ids)]})
self.assertEqual(rec2.tag_ids, tags)
with self.assertQueryCount(2):
self.env.invalidate_all()
rec2.write({'tag_ids': [Command.set(tags.ids)]})
self.assertEqual(rec2.tag_ids, tags)
def test_mixing_tax_inside_and_outside_a_group_of_taxes(self):
percent_tax = self.env['account.tax'].create({
'name': "percent_tax",
'amount_type': 'percent',
'amount': 10.0,
})
tax_group = self.env['account.tax'].create({
'name':
"tax_group",
'amount_type':
'group',
'children_tax_ids': [Command.set(percent_tax.ids)],
})
invoice = self.env['account.move'].create({
'move_type':
'out_invoice',
'partner_id':
self.partner_a.id,
'invoice_date':
'2019-01-01',
'invoice_line_ids': [
Command.create({
'name':
'line1',
'account_id':
self.company_data['default_account_revenue'].id,
'price_unit':
1000.0,
'tax_ids': [Command.set(percent_tax.ids)],
}),
Command.create({
'name':
'line2',
'account_id':
self.company_data['default_account_revenue'].id,
'price_unit':
1000.0,
'tax_ids': [Command.set(tax_group.ids)],
}),
]
})
base_lines, tax_lines = self._dispatch_move_lines(invoice)
tax_details = self._get_tax_details()
self.assertTaxDetailsValues(
tax_details,
[
{
'base_line_id': base_lines[0].id,
'tax_line_id': tax_lines[0].id,
'base_amount': -1000.0,
'tax_amount': -100.0,
},
{
'base_line_id': base_lines[1].id,
'tax_line_id': tax_lines[1].id,
'base_amount': -1000.0,
'tax_amount': -100.0,
},
],
)
self.assertTotalAmounts(invoice, tax_details)
def test_fetch_sale_order_items(self):
""" Test _fetch_sale_order_items and _get_sale_order_items methods
This test will check we have the SOLs linked to the project and its tasks.
Test Case:
=========
1) No SOLs and SO should be found on a non billable project
2) Sol linked to the project should be fetched
3) SOL linked to the project and its task should be fetched
4) Add a employee mapping and check the SOL of this mapping is fetched with the others.
5) remove the SOL linked to the project and check the SOL linked to the task is fetched
6) Add an additional domain in the tasks to check if we can fetch with an additional filter
for instance, only the SOLs linked to the folded tasks.
7) Set allàw_billable=False and check no SOL is found since the project is not billable.
"""
self.assertFalse(self.project_non_billable._fetch_sale_order_items())
self.assertFalse(self.project_non_billable._get_sale_order_items())
self.assertFalse(self.project_non_billable._get_sale_orders())
sale_item = self.so.order_line[0]
self.project_global.sale_line_id = sale_item
self.project_global.write({
'sale_line_id': sale_item.id,
})
self.project_global.invalidate_cache()
expected_task_sale_order_items = self.project_global.tasks.sale_line_id
expected_sale_order_items = sale_item | expected_task_sale_order_items
self.assertEqual(self.project_global._fetch_sale_order_items(),
expected_sale_order_items)
self.assertEqual(self.project_global._get_sale_order_items(),
expected_sale_order_items)
self.assertEqual(self.project_global._get_sale_orders(), self.so)
task = self.env['project.task'].create({
'name':
'Task with SOL',
'project_id':
self.project_global.id,
'sale_line_id':
self.so.order_line[1].id,
})
self.assertEqual(task.project_id, self.project_global)
self.assertEqual(task.sale_line_id, self.so.order_line[1])
self.assertEqual(task.sale_order_id, self.so)
sale_lines = self.project_global._get_sale_order_items()
self.assertEqual(
sale_lines, task.sale_line_id + self.project_global.sale_line_id,
'The Sales Order Items found should be the one linked to the project and the one of project task.'
)
self.assertEqual(
self.project_global._get_sale_orders(), self.so,
'The Sales Order fetched should be the one of the both sale_lines fetched.'
)
employee_mapping = self.env['project.sale.line.employee.map'].create({
'project_id':
self.project_global.id,
'employee_id':
self.employee_user.id,
'sale_line_id':
self.so.order_line[-1].id,
})
expected_sale_order_items |= employee_mapping.sale_line_id
self.assertEqual(self.project_global._get_sale_order_items(),
expected_sale_order_items)
self.assertEqual(self.project_global._get_sale_orders(),
expected_sale_order_items.order_id)
self.project_global.write({
'sale_line_id': False,
})
self.project_global.invalidate_cache()
expected_task_sale_order_items |= task.sale_line_id
self.assertEqual(
self.project_global._get_sale_order_items(),
expected_task_sale_order_items | employee_mapping.sale_line_id)
self.assertEqual(self.project_global._get_sale_orders(), self.so)
new_stage = self.env['project.task.type'].create({
'name':
'New',
'sequence':
1,
'project_ids': [Command.set(self.project_global.ids)],
})
done_stage = self.env['project.task.type'].create({
'name':
'Done',
'sequence':
2,
'project_ids': [Command.set(self.project_global.ids)],
'fold':
True,
})
task.write({
'stage_id': done_stage.id,
})
self.env['project.task.type'].flush()
self.assertEqual(
self.project_global._fetch_sale_order_items(
{'project.task': [('stage_id.fold', '=', False)]}),
employee_mapping.sale_line_id)
self.assertEqual(
self.project_global._fetch_sale_order_items(
{'project.task': [('stage_id.fold', '=', True)]}),
task.sale_line_id | employee_mapping.sale_line_id)
task2 = self.env['project.task'].create({
'name':
'Task 2',
'project_id':
self.project_global.id,
'sale_line_id':
sale_item.id,
'stage_id':
new_stage.id,
})
self.assertEqual(
self.project_global._fetch_sale_order_items(
{'project.task': [('stage_id.fold', '=', False)]}),
task2.sale_line_id | employee_mapping.sale_line_id)
self.assertEqual(
self.project_global._fetch_sale_order_items(
{'project.task': [('stage_id.fold', '=', True)]}),
task.sale_line_id | employee_mapping.sale_line_id)
self.project_global.allow_billable = False
self.assertFalse(self.project_global._get_sale_order_items())
self.assertFalse(self.project_global._get_sale_orders())
def test_write_base_one2many(self):
""" Write on one2many field. """
rec1 = self.env['test_performance.base'].create({'name': 'X'})
# create N lines on rec1: O(N) queries
with self.assertQueryCount(3):
self.env.invalidate_all()
rec1.write({'line_ids': [Command.create({'value': 0})]})
self.assertEqual(len(rec1.line_ids), 1)
with self.assertQueryCount(5):
self.env.invalidate_all()
rec1.write({'line_ids': [Command.create({'value': val}) for val in range(1, 12)]})
self.assertEqual(len(rec1.line_ids), 12)
lines = rec1.line_ids
# update N lines: O(N) queries
with self.assertQueryCount(6):
self.env.invalidate_all()
rec1.write({'line_ids': [Command.update(line.id, {'value': 42}) for line in lines[0]]})
self.assertEqual(rec1.line_ids, lines)
with self.assertQueryCount(26):
self.env.invalidate_all()
rec1.write({'line_ids': [Command.update(line.id, {'value': 42 + line.id}) for line in lines[1:]]})
self.assertEqual(rec1.line_ids, lines)
# delete N lines: O(1) queries
with self.assertQueryCount(14):
self.env.invalidate_all()
rec1.write({'line_ids': [Command.delete(line.id) for line in lines[0]]})
self.assertEqual(rec1.line_ids, lines[1:])
with self.assertQueryCount(12):
self.env.invalidate_all()
rec1.write({'line_ids': [Command.delete(line.id) for line in lines[1:]]})
self.assertFalse(rec1.line_ids)
self.assertFalse(lines.exists())
rec1.write({'line_ids': [Command.create({'value': val}) for val in range(12)]})
lines = rec1.line_ids
# unlink N lines: O(1) queries
with self.assertQueryCount(14):
self.env.invalidate_all()
rec1.write({'line_ids': [Command.unlink(line.id) for line in lines[0]]})
self.assertEqual(rec1.line_ids, lines[1:])
with self.assertQueryCount(12):
self.env.invalidate_all()
rec1.write({'line_ids': [Command.unlink(line.id) for line in lines[1:]]})
self.assertFalse(rec1.line_ids)
self.assertFalse(lines.exists())
rec1.write({'line_ids': [Command.create({'value': val}) for val in range(12)]})
lines = rec1.line_ids
rec2 = self.env['test_performance.base'].create({'name': 'X'})
# link N lines from rec1 to rec2: O(1) queries
with self.assertQueryCount(8):
self.env.invalidate_all()
rec2.write({'line_ids': [Command.link(line.id) for line in lines[0]]})
self.assertEqual(rec1.line_ids, lines[1:])
self.assertEqual(rec2.line_ids, lines[0])
with self.assertQueryCount(8):
self.env.invalidate_all()
rec2.write({'line_ids': [Command.link(line.id) for line in lines[1:]]})
self.assertFalse(rec1.line_ids)
self.assertEqual(rec2.line_ids, lines)
with self.assertQueryCount(4):
self.env.invalidate_all()
rec2.write({'line_ids': [Command.link(line.id) for line in lines[0]]})
self.assertEqual(rec2.line_ids, lines)
with self.assertQueryCount(4):
self.env.invalidate_all()
rec2.write({'line_ids': [Command.link(line.id) for line in lines[1:]]})
self.assertEqual(rec2.line_ids, lines)
# empty N lines in rec2: O(1) queries
with self.assertQueryCount(13):
self.env.invalidate_all()
rec2.write({'line_ids': [Command.clear()]})
self.assertFalse(rec2.line_ids)
with self.assertQueryCount(3):
self.env.invalidate_all()
rec2.write({'line_ids': [Command.clear()]})
self.assertFalse(rec2.line_ids)
rec1.write({'line_ids': [Command.create({'value': val}) for val in range(12)]})
lines = rec1.line_ids
# set N lines in rec2: O(1) queries
with self.assertQueryCount(8):
self.env.invalidate_all()
rec2.write({'line_ids': [Command.set(lines[0].ids)]})
self.assertEqual(rec1.line_ids, lines[1:])
self.assertEqual(rec2.line_ids, lines[0])
with self.assertQueryCount(6):
self.env.invalidate_all()
rec2.write({'line_ids': [Command.set(lines.ids)]})
self.assertFalse(rec1.line_ids)
self.assertEqual(rec2.line_ids, lines)
with self.assertQueryCount(4):
self.env.invalidate_all()
rec2.write({'line_ids': [Command.set(lines.ids)]})
self.assertEqual(rec2.line_ids, lines)
def _load_partners_set(cls):
cls.partner_category = cls.env['res.partner.category'].create({
'name': 'Sellers',
'color': 2,
})
cls.partner_category_child_1 = cls.env['res.partner.category'].create({
'name': 'Office Supplies',
'parent_id': cls.partner_category.id,
})
cls.partner_category_child_2 = cls.env['res.partner.category'].create({
'name': 'Desk Manufacturers',
'parent_id': cls.partner_category.id,
})
# Load all the demo partners
cls.partners = cls.env['res.partner'].create([
{
'name': 'Inner Works', # Wood Corner
'state_id': cls.env.ref('base.state_us_1').id,
'category_id': [Command.set([cls.partner_category_child_1.id, cls.partner_category_child_2.id,])],
'child_ids': [Command.create({
'name': 'Sheila Ruiz', # 'Willie Burke',
}), Command.create({
'name': 'Wyatt Howard', # 'Ron Gibson',
}), Command.create({
'name': 'Austin Kennedy', # Tom Ruiz
})],
}, {
'name': 'Pepper Street', # 'Deco Addict',
'state_id': cls.env.ref('base.state_us_2').id,
'child_ids': [Command.create({
'name': 'Liam King', # 'Douglas Fletcher',
}), Command.create({
'name': 'Craig Richardson', # 'Floyd Steward',
}), Command.create({
'name': 'Adam Cox', # 'Addison Olson',
})],
}, {
'name': 'AnalytIQ', #'Gemini Furniture',
'state_id': cls.env.ref('base.state_us_3').id,
'child_ids': [Command.create({
'name': 'Pedro Boyd', # Edwin Hansen
}), Command.create({
'name': 'Landon Roberts', # 'Jesse Brown',
'company_id': cls.env.ref('base.main_company').id,
}), Command.create({
'name': 'Leona Shelton', # 'Soham Palmer',
}), Command.create({
'name': 'Scott Kim', # 'Oscar Morgan',
})],
}, {
'name': 'Urban Trends', # 'Ready Mat',
'state_id': cls.env.ref('base.state_us_4').id,
'category_id': [Command.set([cls.partner_category_child_1.id, cls.partner_category_child_2.id,])],
'child_ids': [Command.create({
'name': 'Louella Jacobs', # 'Billy Fox',
}), Command.create({
'name': 'Albert Alexander', # 'Kim Snyder',
}), Command.create({
'name': 'Brad Castillo', # 'Edith Sanchez',
}), Command.create({
'name': 'Sophie Montgomery', # 'Sandra Neal',
}), Command.create({
'name': 'Chloe Bates', # 'Julie Richards',
}), Command.create({
'name': 'Mason Crawford', # 'Travis Mendoza',
}), Command.create({
'name': 'Elsie Kennedy', # 'Theodore Gardner',
})],
}, {
'name': 'Ctrl-Alt-Fix', # 'The Jackson Group',
'state_id': cls.env.ref('base.state_us_5').id,
'child_ids': [Command.create({
'name': 'carole miller', # 'Toni Rhodes',
}), Command.create({
'name': 'Cecil Holmes', # 'Gordon Owens',
})],
}, {
'name': 'Ignitive Labs', # 'Azure Interior',
'state_id': cls.env.ref('base.state_us_6').id,
'child_ids': [Command.create({
'name': 'Jonathan Webb', # 'Brandon Freeman',
}), Command.create({
'name': 'Clinton Clark', # 'Nicole Ford',
}), Command.create({
'name': 'Howard Bryant', # 'Colleen Diaz',
})],
}, {
'name': 'Amber & Forge', # 'Lumber Inc',
'state_id': cls.env.ref('base.state_us_7').id,
'child_ids': [Command.create({
'name': 'Mark Webb', # 'Lorraine Douglas',
})],
}, {
'name': 'Rebecca Day', # 'Chester Reed',
'parent_id': cls.env.ref('base.main_partner').id,
}, {
'name': 'Gabriella Jennings', # 'Dwayne Newman',
'parent_id': cls.env.ref('base.main_partner').id,
}
])
def test_ir_rule(self):
model_res_partner = self.env.ref('base.model_res_partner')
group_user = self.env.ref('base.group_user')
# create an ir_rule for the Employee group with an blank domain
rule1 = self.env['ir.rule'].create({
'name': 'test_rule1',
'model_id': model_res_partner.id,
'domain_force': False,
'groups': [Command.set(group_user.ids)],
})
# read as demo user the partners (one blank domain)
partners_demo = self.env['res.partner'].with_user(self.user_demo)
partners = partners_demo.search([])
self.assertTrue(partners, "Demo user should see some partner.")
# same with domain 1=1
rule1.domain_force = "[(1,'=',1)]"
partners = partners_demo.search([])
self.assertTrue(partners, "Demo user should see some partner.")
# same with domain []
rule1.domain_force = "[]"
partners = partners_demo.search([])
self.assertTrue(partners, "Demo user should see some partner.")
# create another ir_rule for the Employee group (to test multiple rules)
rule2 = self.env['ir.rule'].create({
'name': 'test_rule2',
'model_id': model_res_partner.id,
'domain_force': False,
'groups': [Command.set(group_user.ids)],
})
# read as demo user with domains [] and blank
partners = partners_demo.search([])
self.assertTrue(partners, "Demo user should see some partner.")
# same with domains 1=1 and blank
rule1.domain_force = "[(1,'=',1)]"
partners = partners_demo.search([])
self.assertTrue(partners, "Demo user should see some partner.")
# same with domains 1=1 and 1=1
rule2.domain_force = "[(1,'=',1)]"
partners = partners_demo.search([])
self.assertTrue(partners, "Demo user should see some partner.")
# create another ir_rule for the Employee group (to test multiple rules)
rule3 = self.env['ir.rule'].create({
'name': 'test_rule3',
'model_id': model_res_partner.id,
'domain_force': False,
'groups': [Command.set(group_user.ids)],
})
# read the partners as demo user
partners = partners_demo.search([])
self.assertTrue(partners, "Demo user should see some partner.")
# same with domains 1=1, 1=1 and 1=1
rule3.domain_force = "[(1,'=',1)]"
partners = partners_demo.search([])
self.assertTrue(partners, "Demo user should see some partner.")
# modify the global rule on res_company which triggers a recursive check
# of the rules on company
global_rule = self.env.ref('base.res_company_rule_employee')
global_rule.domain_force = "[('id','in', company_ids)]"
# read as demo user (exercising the global company rule)
partners = partners_demo.search([])
self.assertTrue(partners, "Demo user should see some partner.")
# Modify the ir_rule for employee to have a rule that fordids seeing any
# record. We use a domain with implicit AND operator for later tests on
# normalization.
rule2.domain_force = "[('id','=',False),('name','=',False)]"
# check that demo user still sees partners, because group-rules are OR'ed
partners = partners_demo.search([])
self.assertTrue(partners, "Demo user should see some partner.")
# create a new group with demo user in it, and a complex rule
group_test = self.env['res.groups'].create({
'name': 'Test Group',
'users': [Command.set(self.user_demo.ids)],
})
# add the rule to the new group, with a domain containing an implicit
# AND operator, which is more tricky because it will have to be
# normalized before combining it
rule3.write({
'domain_force': "[('name','!=',False),('id','!=',False)]",
'groups': [Command.set(group_test.ids)],
})
# read the partners again as demo user, which should give results
partners = partners_demo.search([])
self.assertTrue(partners, "Demo user should see partners even with the combined rules.")
# delete global domains (to combine only group domains)
self.env['ir.rule'].search([('groups', '=', False)]).unlink()
# read the partners as demo user (several group domains, no global domain)
partners = partners_demo.search([])
self.assertTrue(partners, "Demo user should see some partners.")
def test_send_rating_review(self):
project_settings = self.env["res.config.settings"].create(
{'group_project_rating': True})
project_settings.execute()
self.assertTrue(
self.project_goats.rating_active,
'The customer ratings should be enabled in this project.')
won_stage = self.project_goats.type_ids[-1]
rating_request_mail_template = self.env.ref(
'project.rating_project_request_email_template')
won_stage.write(
{'rating_template_id': rating_request_mail_template.id})
tasks = self.env['project.task'].with_context(
mail_create_nolog=True,
default_project_id=self.project_goats.id).create([
{
'name': 'Goat Task 1',
'user_ids': [Command.set([])]
},
{
'name': 'Goat Task 2',
'user_ids': [Command.link(self.user_projectuser.id)]
},
{
'name':
'Goat Task 3',
'user_ids': [
Command.link(self.user_projectmanager.id),
Command.link(self.user_projectuser.id),
],
},
])
with self.mock_mail_gateway():
tasks.with_user(self.user_projectmanager).write(
{'stage_id': won_stage.id})
tasks.invalidate_cache(fnames=['rating_ids'])
for task in tasks:
self.assertEqual(
len(task.rating_ids), 1,
'This task should have a generated rating when it arrives in the Won stage.'
)
rating_request_message = task.message_ids[:1]
if not task.user_ids or len(task.user_ids) > 1:
self.assertFalse(
task.rating_ids.rated_partner_id,
'This rating should have no assigned user if the task related have no assignees or more than one assignee.'
)
self.assertEqual(
rating_request_message.email_from,
self.user_projectmanager.partner_id.email_formatted,
'The message should have the email of the Project Manager as email from.'
)
else:
self.assertEqual(
task.rating_ids.rated_partner_id, task.user_ids.partner_id,
'The rating should have an assigned user if the task has only one assignee.'
)
self.assertEqual(
rating_request_message.email_from,
task.user_ids.partner_id.email_formatted,
'The message should have the email of the assigned user in the task as email from.'
)
self.assertTrue(
self.partner_1 in rating_request_message.partner_ids,
'The customer of the task should be in the partner_ids of the rating request message.'
)
def test_project_user_can_create_private_task_for_another_user(self):
self.create_private_task(
'Private task', user_ids=[Command.set(self.user_projectuser.ids)])
def create_private_task(self, name, with_user=None, **kwargs):
user = with_user or self.env.user
values = {'name': name, 'user_ids': [Command.set(user.ids)], **kwargs}
return self.env['project.task'].with_user(user).create(values)
