19.0 vanilla

This commit is contained in:
Ernad Husremovic 2026-03-09 09:31:00 +01:00
parent a1137a1456
commit e1d89e11e3
2789 changed files with 1093187 additions and 605897 deletions

View file

@ -1,313 +1,214 @@
# Part of Odoo. See LICENSE file for full copyright and licensing details.
from odoo import fields, Command
from odoo.addons.mail.tests.common import MailCase
from odoo import fields
from odoo.addons.hr_expense.tests.common import TestExpenseCommon
from odoo.tests import tagged
@tagged('-at_install', 'post_install')
class TestExpensesStates(TestExpenseCommon):
class TestExpensesStates(TestExpenseCommon, MailCase):
@classmethod
def setUpClass(cls, chart_template_ref=None):
super().setUpClass(chart_template_ref=chart_template_ref)
cls.expense_states_employee_sheet = cls.env['hr.expense.sheet'].create({
def setUpClass(cls):
super().setUpClass()
cls.expenses_employee = cls.create_expenses({
'name': 'Expense Employee 1',
'employee_id': cls.expense_employee.id,
'expense_line_ids': [Command.create({
'name': 'Expense Employee 1',
'employee_id': cls.expense_employee.id,
'product_id': cls.product_c.id,
'total_amount': 100.00,
})],
})
cls.expense_states_company_sheet = cls.env['hr.expense.sheet'].create({
cls.expenses_company = cls.create_expenses({
'name': 'Expense Company 1',
'employee_id': cls.expense_employee.id,
'expense_line_ids': [Command.create({
'name': 'Expense Company 1',
'payment_mode': 'company_account',
'employee_id': cls.expense_employee.id,
'product_id': cls.product_c.id,
'total_amount': 100.00,
})],
'payment_mode': 'company_account',
# To avoid duplicated expense wizard
'total_amount_currency': 1000,
'date': '2017-01-01',
})
cls.expense_states_sheets = cls.expense_states_employee_sheet + cls.expense_states_company_sheet
cls.expenses_all = cls.expenses_employee + cls.expenses_company
cls.paid_or_in_payment_state = cls.env['account.move']._get_invoice_in_payment_state()
def test_expense_state_synchro_1_regular_flow(self):
# STEP 1: Draft
self.assertRecordValues(self.expense_states_sheets.expense_line_ids, [
{'payment_mode': 'own_account', 'state': 'draft'},
self.assertRecordValues(self.expenses_all, [
{'payment_mode': 'own_account', 'state': 'draft'},
{'payment_mode': 'company_account', 'state': 'draft'},
])
self.assertRecordValues(self.expense_states_sheets, [
{'payment_mode': 'own_account', 'state': 'draft', 'payment_state': 'not_paid'},
{'payment_mode': 'company_account', 'state': 'draft', 'payment_state': 'not_paid'},
])
self.assertFalse(self.expense_states_sheets.account_move_id)
self.assertFalse(self.expenses_all.account_move_id)
# STEP 2: Submit
self.expense_states_sheets.action_submit_sheet()
self.assertRecordValues(self.expense_states_sheets.expense_line_ids, [
{'payment_mode': 'own_account', 'state': 'reported'},
{'payment_mode': 'company_account', 'state': 'reported'},
])
self.assertRecordValues(self.expense_states_sheets, [
{'payment_mode': 'own_account', 'state': 'submit', 'payment_state': 'not_paid'},
{'payment_mode': 'company_account', 'state': 'submit', 'payment_state': 'not_paid'},
self.expenses_all.action_submit()
self.assertRecordValues(self.expenses_all, [
{'payment_mode': 'own_account', 'state': 'submitted'},
{'payment_mode': 'company_account', 'state': 'submitted'},
])
self.assertFalse(self.expenses_all.account_move_id)
# STEP 3: Approve
self.expense_states_sheets.approve_expense_sheets()
self.assertRecordValues(self.expense_states_sheets.expense_line_ids, [
{'payment_mode': 'own_account', 'state': 'approved'},
self.expenses_all.action_approve()
self.assertRecordValues(self.expenses_all, [
{'payment_mode': 'own_account', 'state': 'approved'},
{'payment_mode': 'company_account', 'state': 'approved'},
])
self.assertRecordValues(self.expense_states_sheets, [
{'payment_mode': 'own_account', 'state': 'approve', 'payment_state': 'not_paid'},
{'payment_mode': 'company_account', 'state': 'approve', 'payment_state': 'not_paid'},
])
self.assertFalse(self.expense_states_sheets.account_move_id)
self.assertFalse(self.expenses_all.account_move_id)
# STEP 4: Post
self.expense_states_sheets.action_sheet_move_create()
self.assertRecordValues(self.expense_states_sheets.expense_line_ids, [
{'payment_mode': 'own_account', 'state': 'approved'},
{'payment_mode': 'company_account', 'state': 'done'},
# STEP 4: Post (create moves)
self.post_expenses_with_wizard(self.expenses_all)
self.assertRecordValues(self.expenses_all, [
{'payment_mode': 'own_account', 'state': 'posted'},
{'payment_mode': 'company_account', 'state': 'paid'},
])
self.assertRecordValues(self.expense_states_sheets, [
{'payment_mode': 'own_account', 'state': 'post', 'payment_state': 'not_paid'},
{'payment_mode': 'company_account', 'state': 'done', 'payment_state': 'paid'},
])
self.assertRecordValues(self.expense_states_sheets.account_move_id, [
{'state': 'posted'},
{'state': 'posted'},
self.assertRecordValues(self.expenses_all.account_move_id, [
{'state': 'posted', 'payment_state': 'not_paid'},
{'state': 'posted', 'payment_state': 'not_paid'},
])
def test_expense_state_synchro_2_employee_specific_flow(self):
self.expense_states_sheets.action_submit_sheet()
self.expense_states_sheets.approve_expense_sheets()
self.expense_states_sheets.action_sheet_move_create()
self.assertEqual('in_process', self.expenses_company.account_move_id.origin_payment_id.state)
self.assertFalse(self.expenses_employee.account_move_id.origin_payment_id)
# STEP 1: ER posted -> Reset move to draft
self.expense_states_employee_sheet.account_move_id.button_draft()
self.assertRecordValues(self.expense_states_employee_sheet.expense_line_ids, [
{'state': 'approved'},
def test_expense_state_synchro_1_cancel_move(self):
""" Posted -> Cancel move (Back to approved) """
self.expenses_all.action_submit()
self.expenses_all.action_approve()
self.post_expenses_with_wizard(self.expenses_all)
self.expenses_all.account_move_id.button_draft()
self.expenses_all.account_move_id.button_cancel()
self.assertRecordValues(self.expenses_all, [
{'state': 'approved', 'account_move_id': False},
{'state': 'approved', 'account_move_id': False},
])
self.assertRecordValues(self.expense_states_employee_sheet, [
{'state': 'post', 'payment_state': 'not_paid'},
])
self.assertRecordValues(self.expense_states_employee_sheet.account_move_id, [
{'state': 'draft'},
self.assertFalse(self.expenses_all.account_move_id)
def test_expense_state_synchro_1_unlink_move(self):
""" Posted -> Unlink move/payment (Back to approved) """
self.expenses_all.action_submit()
self.expenses_all.action_approve()
self.post_expenses_with_wizard(self.expenses_all)
self.expenses_all.account_move_id.button_draft()
self.expenses_all.account_move_id.origin_payment_id.unlink()
self.expenses_all.account_move_id.unlink()
self.assertRecordValues(self.expenses_all, [
{'state': 'approved', 'account_move_id': False},
{'state': 'approved', 'account_move_id': False},
])
# STEP 2: ER posted with draft move -> Cancel move (nothing changes)
self.expense_states_employee_sheet.account_move_id.button_cancel()
self.assertRecordValues(self.expense_states_employee_sheet.expense_line_ids, [
{'state': 'approved'},
])
self.assertRecordValues(self.expense_states_employee_sheet, [
{'state': 'post', 'payment_state': 'not_paid'},
])
self.assertRecordValues(self.expense_states_employee_sheet.account_move_id, [
{'state': 'cancel'},
])
def test_expense_state_synchro_1_reverse_move(self):
""" Posted -> Reverse move (Back to approved) """
self.expenses_all.action_submit()
self.expenses_all.action_approve()
self.post_expenses_with_wizard(self.expenses_all)
# Change move state to draft
self.expense_states_employee_sheet.account_move_id.button_draft()
# STEP 3: ER posted with draft move -> unlink move (Reverts to approve state)
self.expense_states_employee_sheet.account_move_id.unlink()
self.assertRecordValues(self.expense_states_employee_sheet.expense_line_ids, [
{'state': 'approved'},
])
self.assertRecordValues(self.expense_states_employee_sheet, [
{'state': 'approve', 'payment_state': 'not_paid'},
])
self.assertFalse(self.expense_states_employee_sheet.account_move_id)
# Re-create posted move
self.expense_states_employee_sheet.action_sheet_move_create()
# STEP 4: ER with draft move -> Reverse move (Reverts to approve state)
self.expense_states_employee_sheet.account_move_id._reverse_moves(
default_values_list=[{'invoice_date': fields.Date.context_today(self.expense_states_employee_sheet)}],
self.expenses_all.account_move_id._reverse_moves(
default_values_list=[{'invoice_date': fields.Date.context_today(self.expenses_all)}],
cancel=True,
)
self.assertRecordValues(self.expense_states_employee_sheet.expense_line_ids, [
{'state': 'approved'},
])
self.assertRecordValues(self.expense_states_employee_sheet, [
{'state': 'approve', 'payment_state': 'not_paid'},
])
self.assertFalse(self.expense_states_employee_sheet.account_move_id)
# Change the report state to a partially paid one
self.expense_states_employee_sheet.action_sheet_move_create()
action_context = self.expense_states_employee_sheet.action_register_payment()['context']
self.env['account.payment.register'].with_context(action_context).create({'amount': 1})._create_payments()
# STEP 5: ER Done (partially paid) -> Reset move to draft
self.expense_states_employee_sheet.account_move_id.button_draft()
self.assertRecordValues(self.expense_states_employee_sheet.expense_line_ids, [
{'state': 'approved'},
])
self.assertRecordValues(self.expense_states_employee_sheet, [
{'state': 'post', 'payment_state': 'not_paid'},
])
self.assertRecordValues(self.expense_states_employee_sheet.account_move_id, [
{'state': 'draft'},
self.assertRecordValues(self.expenses_all, [
{'state': 'approved', 'account_move_id': False},
{'state': 'approved', 'account_move_id': False},
])
# Re-post the move & partially pay it
self.expense_states_employee_sheet.account_move_id.action_post()
action_context = self.expense_states_employee_sheet.action_register_payment()['context']
self.env['account.payment.register'].with_context(action_context).create({'amount': 1})._create_payments()
def test_expense_state_synchro_2_employee_specific_flow_1(self):
""" Posted -> Reset move to draft (No change)"""
self.expenses_employee.action_submit()
self.expenses_employee.action_approve()
self.post_expenses_with_wizard(self.expenses_employee)
# STEP 6: ER Done (partially paid) -> fully paid
action_context = self.expense_states_employee_sheet.action_register_payment()['context']
self.env['account.payment.register'].with_context(action_context).create(
{'amount': self.expense_states_employee_sheet.amount_residual}
)._create_payments()
self.assertRecordValues(self.expense_states_employee_sheet.expense_line_ids, [
{'state': 'done'},
self.expenses_employee.account_move_id.button_draft()
self.assertEqual(self.expenses_employee.state, 'posted')
self.assertRecordValues(self.expenses_employee.account_move_id, [
{'state': 'draft', 'payment_state': 'not_paid'},
])
self.assertRecordValues(self.expense_states_employee_sheet, [
{'state': 'done', 'payment_state': self.paid_or_in_payment_state},
])
self.assertRecordValues(self.expense_states_employee_sheet.account_move_id, [
def test_expense_state_synchro_2_employee_specific_flow_2(self):
""" Posted -> Paid in one payment (Set to paid) """
self.expenses_employee.action_submit()
self.expenses_employee.action_approve()
self.post_expenses_with_wizard(self.expenses_employee)
self.get_new_payment(self.expenses_employee, self.expenses_employee.total_amount)
self.assertEqual(self.expenses_employee.state, self.paid_or_in_payment_state)
self.assertRecordValues(self.expenses_employee.account_move_id, [
{'state': 'posted', 'payment_state': self.paid_or_in_payment_state},
])
# STEP 7: ER Done (fully paid) -> Reset move to draft
self.expense_states_employee_sheet.account_move_id.button_draft()
self.assertRecordValues(self.expense_states_employee_sheet.expense_line_ids, [
{'state': 'approved'},
])
self.assertRecordValues(self.expense_states_employee_sheet, [
{'state': 'post', 'payment_state': 'not_paid'},
])
self.assertRecordValues(self.expense_states_employee_sheet.account_move_id, [
{'state': 'draft'},
def test_expense_state_synchro_2_employee_specific_flow_3(self):
""" Posted -> Paid in several payment (Set to paid, even when partially)"""
self.expenses_employee.action_submit()
self.expenses_employee.action_approve()
self.post_expenses_with_wizard(self.expenses_employee)
self.get_new_payment(self.expenses_employee, 1)
self.assertEqual(self.expenses_employee.state, self.paid_or_in_payment_state)
self.assertRecordValues(self.expenses_employee.account_move_id, [
{'state': 'posted', 'payment_state': 'partial'},
])
# Change the report state to a paid one
self.expense_states_employee_sheet.account_move_id.unlink()
self.expense_states_employee_sheet.action_sheet_move_create()
action_context = self.expense_states_employee_sheet.action_register_payment()['context']
payment = self.env['account.payment.register'].with_context(action_context).create({})._create_payments()
self.assertRecordValues(self.expense_states_employee_sheet.expense_line_ids, [
{'state': 'done'},
])
self.assertRecordValues(self.expense_states_employee_sheet, [
{'state': 'done', 'payment_state': self.paid_or_in_payment_state},
])
self.assertRecordValues(self.expense_states_employee_sheet.account_move_id, [
{'state': 'posted'},
self.get_new_payment(self.expenses_employee, self.expenses_employee.total_amount - 1)
self.assertEqual(self.expenses_employee.state, self.paid_or_in_payment_state)
self.assertRecordValues(self.expenses_employee.account_move_id, [
{'state': 'posted', 'payment_state': self.paid_or_in_payment_state},
])
# STEP 8: ER Done (fully paid) -> Reset to draft payment (Reverts to post state)
payment.action_draft()
self.assertRecordValues(self.expense_states_employee_sheet.expense_line_ids, [
{'state': 'approved'},
])
self.assertRecordValues(self.expense_states_employee_sheet, [
{'state': 'post', 'payment_state': 'not_paid'},
])
self.assertRecordValues(self.expense_states_employee_sheet.account_move_id, [
{'state': 'posted'},
def test_expense_state_synchro_2_employee_specific_flow_4(self):
""" (Partially/) Paid -> Reset move to draft (Back to posted) """
self.expenses_employee.action_submit()
self.expenses_employee.action_approve()
self.post_expenses_with_wizard(self.expenses_employee)
self.get_new_payment(self.expenses_employee, self.expenses_employee.total_amount)
self.expenses_employee.account_move_id.button_draft()
self.expenses_employee.account_move_id.line_ids.remove_move_reconcile()
self.assertEqual(self.expenses_employee.state, 'posted')
self.assertRecordValues(self.expenses_employee.account_move_id, [
{'state': 'draft', 'payment_state': 'not_paid'},
])
def test_expense_state_synchro_3_company_specific_flow(self):
self.expense_states_company_sheet.action_submit_sheet()
self.expense_states_company_sheet.approve_expense_sheets()
self.expense_states_company_sheet.action_sheet_move_create()
""" Paid -> Reset move or payment to draft (Stay paid) """
self.expenses_company.action_submit()
self.expenses_company.action_approve()
self.expenses_company.action_post()
# STEP 1: ER Done & paid -> Reset move or payment to draft (nothing changes)
self.expense_states_company_sheet.account_move_id.button_draft()
self.assertRecordValues(self.expense_states_company_sheet.expense_line_ids, [
{'state': 'done'},
])
self.assertRecordValues(self.expense_states_company_sheet, [
{'state': 'done', 'payment_state': 'paid'},
])
self.assertRecordValues(self.expense_states_company_sheet.account_move_id, [
{'state': 'draft'},
self.expenses_company.account_move_id.button_draft()
self.assertEqual(self.expenses_company.state, 'paid')
self.assertRecordValues(self.expenses_company.account_move_id, [
{'state': 'draft', 'payment_state': 'not_paid'},
])
self.expense_states_company_sheet.account_move_id.action_post()
self.expense_states_company_sheet.account_move_id.payment_id.action_draft()
self.assertRecordValues(self.expense_states_company_sheet.expense_line_ids, [
{'state': 'done'},
])
self.assertRecordValues(self.expense_states_company_sheet, [
{'state': 'done', 'payment_state': 'paid'},
])
self.assertRecordValues(self.expense_states_company_sheet.account_move_id, [
{'state': 'draft'},
self.expenses_company.account_move_id.action_post()
self.assertEqual(self.expenses_company.state, 'paid')
self.expenses_company.account_move_id.origin_payment_id.action_draft()
self.assertEqual(self.expenses_company.state, 'paid')
self.assertRecordValues(self.expenses_company.account_move_id, [
{'state': 'draft', 'payment_state': 'not_paid'},
])
# STEP 2: ER Done & paid (draft move) -> Cancel move or payment (nothing changes)
self.expense_states_company_sheet.account_move_id.button_cancel()
self.assertRecordValues(self.expense_states_company_sheet.expense_line_ids, [
{'state': 'done'},
])
self.assertRecordValues(self.expense_states_company_sheet, [
{'state': 'done', 'payment_state': 'paid'},
])
self.assertRecordValues(self.expense_states_company_sheet.account_move_id, [
{'state': 'cancel'},
])
self.expense_states_company_sheet.account_move_id.button_draft()
self.expense_states_company_sheet.account_move_id.payment_id.action_cancel()
self.assertRecordValues(self.expense_states_company_sheet.expense_line_ids, [
{'state': 'done'},
])
self.assertRecordValues(self.expense_states_company_sheet, [
{'state': 'done', 'payment_state': 'paid'},
])
self.assertRecordValues(self.expense_states_company_sheet.account_move_id, [
{'state': 'cancel'},
])
def test_expense_state_autovalidation(self):
""" Test the auto-validation flow skips 'submitted' state when there is no manager"""
self.expense_employee.sudo().expense_manager_id = False
self.expenses_all.sudo().manager_id = False
self.expenses_all.action_submit()
self.assertSequenceEqual(['approved', 'approved'], self.expenses_all.mapped('state'))
# Change move state to draft
self.expense_states_company_sheet.account_move_id.button_draft()
# STEP 3: ER draft & paid -> Delete move (Back to approve state)
self.expense_states_company_sheet.account_move_id.unlink()
self.assertRecordValues(self.expense_states_company_sheet.expense_line_ids, [
{'state': 'approved'},
])
self.assertRecordValues(self.expense_states_company_sheet, [
{'state': 'approve', 'payment_state': 'not_paid'},
])
self.assertFalse(self.expense_states_company_sheet.account_move_id)
# Re-create posted move
self.expense_states_company_sheet.action_sheet_move_create()
self.assertRecordValues(self.expense_states_company_sheet.expense_line_ids, [
{'state': 'done'},
])
self.assertRecordValues(self.expense_states_company_sheet, [
{'payment_mode': 'company_account', 'state': 'done', 'payment_state': 'paid'},
])
self.assertRecordValues(self.expense_states_company_sheet.account_move_id, [
{'state': 'posted'},
])
# STEP 4: ER Done & paid -> Reverse move (Change payment state to 'reversed')
self.expense_states_company_sheet.account_move_id._reverse_moves(
default_values_list=[{'invoice_date': fields.Date.context_today(self.expense_states_company_sheet)}],
cancel=True,
)
self.assertRecordValues(self.expense_states_company_sheet.expense_line_ids, [
{'state': 'done'},
])
self.assertRecordValues(self.expense_states_company_sheet, [
{'state': 'done', 'payment_state': 'reversed'},
])
self.assertRecordValues(self.expense_states_company_sheet.account_move_id, [
{'state': 'posted'},
])
def test_expense_next_activity(self):
""" Test next activity is assigned to the right manager, no notification is sent, but validation email is sent"""
self.expenses_employee.manager_id = self.expense_user_manager_2
with self.mock_mail_gateway():
self.expenses_employee.action_submit()
self.env['hr.expense']._cron_send_submitted_expenses_mail()
mail_activity = self.env['mail.activity'].search([('res_model', '=', 'hr.expense'), ('res_id', '=', self.expenses_employee.id)])
self.assertEqual(mail_activity.user_id.id, self.expense_user_manager_2.id)
# No notification should be sent
notification_message = self.env['mail.message'].search([('partner_ids', 'in', self.expense_user_manager_2.partner_id.ids), ('display_name', '=', mail_activity.res_name)])
self.assertFalse(notification_message)
# Expenses submitted email is sent via cron
expenses_submitted = self.env['mail.mail'].search(
[('email_to', '=', self.expense_user_manager_2.email),
('subject', '=', "New expenses waiting for your approval")]
)
self.assertEqual(len(expenses_submitted), 1)