Raphael Collet
9920f20e4c
This branch is the combination of several optimizations in the ORM: * store field values once in the cache: the cache reflects more faithfully the database, only fields that explicitly depend on the context have an extra indirection in the cache; * delay recomputations by default: use method `recompute` to explicitly flush out pending recomputations; * delay updates in method `write`: updates are stored in a data structure that can be flushed efficiently to the database with method `flush` (which also flush out recomputations); * make method `modified` take advantage of inverse fields to inverse dependencies; * filter records by evaluating a domain on records in Python; * a computed field with `readonly=False` behaves like a normal field with an onchange method; * computed fields are computed in superuser mode by default. Work done by Toufik Ben Jaa, Raphael Collet, Denis Ledoux and Fabien Pinckaers. closes odoo/odoo#35659 Signed-off-by: Denis Ledoux <beledouxdenis@users.noreply.github.com>
208 lines
9.7 KiB
Python
208 lines
9.7 KiB
Python
# # -*- coding: utf-8 -*-
|
|
# # Part of Odoo. See LICENSE file for full copyright and licensing details.
|
|
from unittest.mock import patch
|
|
|
|
from odoo.tests import common
|
|
|
|
|
|
@common.tagged('post_install','-at_install')
|
|
class base_automation_test(common.TransactionCase):
|
|
|
|
def setUp(self):
|
|
super(base_automation_test, self).setUp()
|
|
self.user_root = self.env.ref('base.user_root')
|
|
self.user_admin = self.env.ref('base.user_admin')
|
|
self.user_demo = self.env.ref('base.user_demo')
|
|
|
|
def create_lead(self, **kwargs):
|
|
vals = {
|
|
'name': "Lead Test",
|
|
'user_id': self.user_root.id,
|
|
}
|
|
vals.update(kwargs)
|
|
return self.env['base.automation.lead.test'].create(vals)
|
|
|
|
def test_00_check_to_state_open_pre(self):
|
|
"""
|
|
Check that a new record (with state = open) doesn't change its responsible
|
|
when there is a precondition filter which check that the state is open.
|
|
"""
|
|
lead = self.create_lead(state='open')
|
|
self.assertEqual(lead.state, 'open')
|
|
self.assertEqual(lead.user_id, self.user_root, "Responsible should not change on creation of Lead with state 'open'.")
|
|
|
|
def test_01_check_to_state_draft_post(self):
|
|
"""
|
|
Check that a new record changes its responsible when there is a postcondition
|
|
filter which check that the state is draft.
|
|
"""
|
|
lead = self.create_lead()
|
|
self.assertEqual(lead.state, 'draft', "Lead state should be 'draft'")
|
|
self.assertEqual(lead.user_id, self.user_demo, "Responsible should be change on creation of Lead with state 'draft'.")
|
|
|
|
def test_02_check_from_draft_to_done_with_steps(self):
|
|
"""
|
|
A new record is created and goes from states 'open' to 'done' via the
|
|
other states (open, pending and cancel). We have a rule with:
|
|
- precondition: the record is in "open"
|
|
- postcondition: that the record is "done".
|
|
If the state goes from 'open' to 'done' the responsible is changed.
|
|
If those two conditions aren't verified, the responsible remains the same.
|
|
"""
|
|
lead = self.create_lead(state='open')
|
|
self.assertEqual(lead.state, 'open', "Lead state should be 'open'")
|
|
self.assertEqual(lead.user_id, self.user_root, "Responsible should not change on creation of Lead with state 'open'.")
|
|
# change state to pending and check that responsible has not changed
|
|
lead.write({'state': 'pending'})
|
|
self.assertEqual(lead.state, 'pending', "Lead state should be 'pending'")
|
|
self.assertEqual(lead.user_id, self.user_root, "Responsible should not change on creation of Lead with state from 'draft' to 'open'.")
|
|
# change state to done and check that responsible has not changed
|
|
lead.write({'state': 'done'})
|
|
self.assertEqual(lead.state, 'done', "Lead state should be 'done'")
|
|
self.assertEqual(lead.user_id, self.user_root, "Responsible should not chang on creation of Lead with state from 'pending' to 'done'.")
|
|
|
|
def test_03_check_from_draft_to_done_without_steps(self):
|
|
"""
|
|
A new record is created and goes from states 'open' to 'done' via the
|
|
other states (open, pending and cancel). We have a rule with:
|
|
- precondition: the record is in "open"
|
|
- postcondition: that the record is "done".
|
|
If the state goes from 'open' to 'done' the responsible is changed.
|
|
If those two conditions aren't verified, the responsible remains the same.
|
|
"""
|
|
lead = self.create_lead(state='open')
|
|
self.assertEqual(lead.state, 'open', "Lead state should be 'open'")
|
|
self.assertEqual(lead.user_id, self.user_root, "Responsible should not change on creation of Lead with state 'open'.")
|
|
# change state to done and check that responsible has changed
|
|
lead.write({'state': 'done'})
|
|
self.assertEqual(lead.state, 'done', "Lead state should be 'done'")
|
|
self.assertEqual(lead.user_id, self.user_demo, "Responsible should be change on write of Lead with state from 'open' to 'done'.")
|
|
|
|
def test_10_recomputed_field(self):
|
|
"""
|
|
Check that a rule is executed whenever a field is recomputed after a
|
|
change on another model.
|
|
"""
|
|
partner = self.env.ref('base.res_partner_1')
|
|
partner.write({'employee': False})
|
|
lead = self.create_lead(state='open', partner_id=partner.id)
|
|
self.assertFalse(lead.employee, "Customer field should updated to False")
|
|
self.assertEqual(lead.user_id, self.user_root, "Responsible should not change on creation of Lead with state from 'draft' to 'open'.")
|
|
# change partner, recompute on lead should trigger the rule
|
|
partner.write({'employee': True})
|
|
lead.flush()
|
|
self.assertTrue(lead.employee, "Customer field should updated to True")
|
|
self.assertEqual(lead.user_id, self.user_demo, "Responsible should be change on write of Lead when Customer becomes True.")
|
|
|
|
def test_11_recomputed_field(self):
|
|
"""
|
|
Check that a rule is executed whenever a field is recomputed and the
|
|
context contains the target field
|
|
"""
|
|
partner = self.env.ref('base.res_partner_1')
|
|
lead = self.create_lead(state='draft', partner_id=partner.id)
|
|
self.assertFalse(lead.deadline, 'There should not be a deadline defined')
|
|
# change priority and user; this triggers deadline recomputation, and
|
|
# the server action should set the boolean field to True
|
|
lead.write({'priority': True, 'user_id': self.user_root.id})
|
|
self.assertTrue(lead.deadline, 'Deadline should be defined')
|
|
self.assertTrue(lead.is_assigned_to_admin, 'Lead should be assigned to admin')
|
|
|
|
def test_11b_recomputed_field(self):
|
|
mail_automation = self.env.ref('base_automation.test_rule_on_write_recompute_send_email')
|
|
send_mail_count = 0
|
|
|
|
def _patched_get_actions(*args, **kwargs):
|
|
obj = args[0]
|
|
if '__action_done' not in obj._context:
|
|
obj = obj.with_context(__action_done={})
|
|
return mail_automation.with_env(obj.env)
|
|
|
|
def _patched_send_mail(*args, **kwargs):
|
|
nonlocal send_mail_count
|
|
send_mail_count += 1
|
|
|
|
patchers = [
|
|
patch('odoo.addons.base_automation.models.base_automation.BaseAutomation._get_actions', _patched_get_actions),
|
|
patch('odoo.addons.mail.models.mail_template.MailTemplate.send_mail', _patched_send_mail),
|
|
]
|
|
|
|
patchers[0].start()
|
|
|
|
lead = self.create_lead()
|
|
self.assertFalse(lead.priority)
|
|
self.assertFalse(lead.deadline)
|
|
|
|
patchers[1].start()
|
|
|
|
lead.write({'priority': True})
|
|
|
|
self.assertTrue(lead.priority)
|
|
self.assertTrue(lead.deadline)
|
|
|
|
for patcher in patchers:
|
|
patcher.stop()
|
|
|
|
self.assertEqual(send_mail_count, 1)
|
|
|
|
def test_12_recursive(self):
|
|
""" Check that a rule is executed recursively by a secondary change. """
|
|
lead = self.create_lead(state='open')
|
|
self.assertEqual(lead.state, 'open')
|
|
self.assertEqual(lead.user_id, self.user_root)
|
|
# change partner; this should trigger the rule that modifies the state
|
|
partner = self.env.ref('base.res_partner_1')
|
|
lead.write({'partner_id': partner.id})
|
|
self.assertEqual(lead.state, 'draft')
|
|
|
|
def test_20_direct_line(self):
|
|
"""
|
|
Check that a rule is executed after creating a line record.
|
|
"""
|
|
line = self.env['base.automation.line.test'].create({'name': "Line"})
|
|
self.assertEqual(line.user_id, self.user_demo)
|
|
|
|
def test_20_indirect_line(self):
|
|
"""
|
|
Check that creating a lead with a line executes rules on both records.
|
|
"""
|
|
lead = self.create_lead(line_ids=[(0, 0, {'name': "Line"})])
|
|
self.assertEqual(lead.state, 'draft', "Lead state should be 'draft'")
|
|
self.assertEqual(lead.user_id, self.user_demo, "Responsible should change on creation of Lead test line.")
|
|
self.assertEqual(len(lead.line_ids), 1, "New test line is not created")
|
|
self.assertEqual(lead.line_ids.user_id, self.user_demo, "Responsible should be change on creation of Lead test line.")
|
|
|
|
def test_21_trigger_fields(self):
|
|
"""
|
|
Check that the rule with trigger is executed only once per pertinent update.
|
|
"""
|
|
lead = self.create_lead(name="X")
|
|
lead.priority = True
|
|
partner1 = self.env.ref('base.res_partner_1')
|
|
lead.partner_id = partner1.id
|
|
self.assertEqual(lead.name, 'X', "No update until now.")
|
|
|
|
lead.state = 'open'
|
|
self.assertEqual(lead.name, 'XX', "One update should have happened.")
|
|
lead.state = 'done'
|
|
self.assertEqual(lead.name, 'XXX', "One update should have happened.")
|
|
lead.state = 'done'
|
|
self.assertEqual(lead.name, 'XXX', "No update should have happened.")
|
|
lead.state = 'cancel'
|
|
self.assertEqual(lead.name, 'XXXX', "One update should have happened.")
|
|
|
|
# change the rule to trigger on partner_id
|
|
rule = self.env.ref('base_automation.test_rule_with_trigger')
|
|
rule.trigger_field_ids = self.env.ref('base_automation.field_base_automation_lead_test__partner_id')
|
|
|
|
partner2 = self.env.ref('base.res_partner_2')
|
|
lead.name = 'X'
|
|
lead.state = 'open'
|
|
self.assertEqual(lead.name, 'X', "No update should have happened.")
|
|
lead.partner_id = partner2
|
|
self.assertEqual(lead.name, 'XX', "One update should have happened.")
|
|
lead.partner_id = partner2
|
|
self.assertEqual(lead.name, 'XX', "No update should have happened.")
|
|
lead.partner_id = partner1
|
|
self.assertEqual(lead.name, 'XXX', "One update should have happened.")
|