# -*- coding: utf-8 -*- # Part of Odoo. See LICENSE file for full copyright and licensing details. import base64 from freezegun import freeze_time from odoo.addons.hr_expense.tests.common import TestExpenseCommon from odoo.tests import tagged, Form from odoo.tools.misc import formatLang, format_date from odoo import fields, Command from odoo.exceptions import UserError, ValidationError @tagged('-at_install', 'post_install') class TestExpenses(TestExpenseCommon): def test_expense_sheet_changing_employee(self): """ Test changing an employee on the expense that is linked with the sheet. - In case sheet has only one expense linked with it, than changing an employee on expense should trigger changing an employee on the sheet itself. - In case sheet has more than one expense linked with it, than changing an employee on one of the expenses, should cause unlinking the expense from the sheet.""" employee = self.env['hr.employee'].create({ 'name': 'Gabriel Iglesias', }) expense1 = self.env['hr.expense'].create({ 'name': 'Dinner with client - Expenses', 'employee_id': self.expense_employee.id, 'product_id': self.product_a.id, 'unit_amount': 350.00, }) expense2 = self.env['hr.expense'].create({ 'name': 'Team building at Huy', 'employee_id': employee.id, 'product_id': self.product_a.id, 'unit_amount': 2500.00, }) expense_sheet = self.env['hr.expense.sheet'].create({ 'name': 'Expense for Jannette', 'employee_id': self.expense_employee.id, 'expense_line_ids': expense1, }) expense1.employee_id = employee self.assertEqual(expense_sheet.employee_id, employee, 'Employee should have changed on the sheet') expense_sheet.expense_line_ids |= expense2 expense2.employee_id = self.expense_employee.id self.assertEqual(expense2.sheet_id.id, False, 'Sheet should be unlinked from the expense') def test_expense_sheet_payment_state(self): ''' Test expense sheet payment states when partially paid, in payment and paid. ''' def get_payment(expense_sheet, amount): ctx = {'active_model': 'account.move', 'active_ids': expense_sheet.account_move_id.ids} payment_register = self.env['account.payment.register'].with_context(**ctx).create({ 'amount': amount, 'journal_id': self.company_data['default_journal_bank'].id, 'payment_method_line_id': self.inbound_payment_method_line.id, }) return payment_register._create_payments() expense_sheet = self.env['hr.expense.sheet'].create({ 'name': 'Expense for John Smith', 'employee_id': self.expense_employee.id, 'accounting_date': '2021-01-01', 'expense_line_ids': [(0, 0, { 'name': 'Car Travel Expenses', 'employee_id': self.expense_employee.id, 'product_id': self.product_a.id, 'unit_amount': 350.00, })] }) expense_sheet.action_submit_sheet() expense_sheet.approve_expense_sheets() expense_sheet.action_sheet_move_create() payment = get_payment(expense_sheet, 100.0) liquidity_lines1 = payment._seek_for_lines()[0] self.assertEqual(expense_sheet.payment_state, 'partial', 'payment_state should be partial') payment = get_payment(expense_sheet, 250.0) liquidity_lines2 = payment._seek_for_lines()[0] in_payment_state = expense_sheet.account_move_id._get_invoice_in_payment_state() self.assertEqual(expense_sheet.payment_state, in_payment_state, 'payment_state should be ' + in_payment_state) statement_line = self.env['account.bank.statement.line'].create({ 'journal_id': self.company_data['default_journal_bank'].id, 'payment_ref': 'pay_ref', 'amount': -350.0, 'partner_id': self.expense_employee.address_home_id.id, }) # Reconcile without the bank reconciliation widget since the widget is in enterprise. _st_liquidity_lines, st_suspense_lines, _st_other_lines = statement_line\ .with_context(skip_account_move_synchronization=True)\ ._seek_for_lines() st_suspense_lines.account_id = liquidity_lines1.account_id (st_suspense_lines + liquidity_lines1 + liquidity_lines2).reconcile() self.assertEqual(expense_sheet.payment_state, 'paid', 'payment_state should be paid') def test_expense_sheet_company_payment_state(self): ''' Test expense sheet company payment states''' expense_sheet = self.env['hr.expense.sheet'].create({ 'name': 'Expense for John Smith', 'employee_id': self.expense_employee.id, 'accounting_date': '2021-01-01', 'expense_line_ids': [(0, 0, { 'name': 'Car Travel Expenses', 'employee_id': self.expense_employee.id, 'product_id': self.product_a.id, 'unit_amount': 350.00, 'payment_mode': 'company_account', })] }) expense_sheet.action_submit_sheet() expense_sheet.approve_expense_sheets() expense_sheet.action_sheet_move_create() self.assertEqual(expense_sheet.payment_state, 'paid', 'payment_state should be paid') liquidity_line = expense_sheet.account_move_id.payment_id._seek_for_lines()[0] statement_line = self.env['account.bank.statement.line'].create({ 'journal_id': self.company_data['default_journal_bank'].id, 'payment_ref': 'pay_ref', 'amount': -350.0, 'partner_id': self.expense_employee.address_home_id.id, }) # Reconcile without the bank reconciliation widget since the widget is in enterprise. _st_liquidity_lines, st_suspense_lines, _st_other_lines = statement_line\ .with_context(skip_account_move_synchronization=True)\ ._seek_for_lines() st_suspense_lines.account_id = liquidity_line.account_id (st_suspense_lines + liquidity_line).reconcile() self.assertEqual(expense_sheet.payment_state, 'paid', 'payment_state should be paid') def test_expense_values(self): """ Checking accounting move entries and analytic entries when submitting expense """ # The expense employee is able to a create an expense sheet. # The total should be 1500.0 because: # - first line: 1000.0 (unit amount), 130.43 (tax). But taxes are included in total thus - 1000 # - second line: (1500.0 (unit amount), 195.652 (tax)) - 65.22 (tax in company currency). total 1500.0 * 1/3 (rate) = 500 expense_sheet = self.env['hr.expense.sheet'].create({ 'name': 'First Expense for employee', 'employee_id': self.expense_employee.id, 'journal_id': self.company_data['default_journal_purchase'].id, 'expense_line_ids': [ (0, 0, { # Expense without foreign currency. 'name': 'expense_company_currency', 'date': '2016-01-01', 'product_id': self.product_a.id, 'unit_amount': 1000.0, 'tax_ids': [(6, 0, self.company_data['default_tax_purchase'].ids)], 'analytic_distribution': {self.analytic_account_1.id: 100}, 'employee_id': self.expense_employee.id, }), (0, 0, { # Expense with foreign currency (rate 1:3). 'name': 'expense_foreign_currency', 'date': '2016-01-01', 'product_id': self.product_c.id, # product with no cost, else not possible to enter amount in different currency 'total_amount': 1500.0, 'tax_ids': [(6, 0, self.company_data['default_tax_purchase'].ids)], 'analytic_distribution': {self.analytic_account_2.id: 100}, 'currency_id': self.currency_data['currency'].id, 'employee_id': self.expense_employee.id, }), ], }) self.assertRecordValues(expense_sheet, [{'state': 'draft', 'total_amount': 1500.0}]) expense_sheet.action_submit_sheet() expense_sheet.approve_expense_sheets() expense_sheet.action_sheet_move_create() # Check expense sheet journal entry values. self.assertRecordValues(expense_sheet.account_move_id.line_ids.sorted('balance'), [ # Receivable line (company currency): { 'debit': 0.0, 'credit': 1500.0, 'amount_currency': -1500.0, 'account_id': self.company_data['default_account_payable'].id, 'product_id': False, 'currency_id': self.company_data['currency'].id, 'tax_line_id': False, 'analytic_distribution': False, }, # Tax line (foreign currency): { 'debit': 65.22, 'credit': 0.0, 'amount_currency': 65.22, 'account_id': self.company_data['default_account_tax_purchase'].id, 'product_id': False, 'currency_id': self.company_data['currency'].id, 'tax_line_id': self.company_data['default_tax_purchase'].id, 'analytic_distribution': False, }, # Tax line (company currency): { 'debit': 130.43, 'credit': 0.0, 'amount_currency': 130.43, 'account_id': self.company_data['default_account_tax_purchase'].id, 'product_id': False, 'currency_id': self.company_data['currency'].id, 'tax_line_id': self.company_data['default_tax_purchase'].id, 'analytic_distribution': False, }, # Product line (foreign currency): { 'debit': 434.78, # 1500 * 1:3 (rate) / 1.15 (incl. tax) 'credit': 0.0, 'amount_currency': 434.78, # untaxed amount 'account_id': self.product_c.property_account_expense_id.id, 'product_id': self.product_c.id, 'currency_id': self.company_data['currency'].id, 'tax_line_id': False, 'analytic_distribution': {str(self.analytic_account_2.id): 100}, }, # Product line (company currency): { 'debit': 869.57, # 1000 * 1:1 (rate) / 1.15 (incl. tax) 'credit': 0.0, 'amount_currency': 869.57, 'account_id': self.company_data['default_account_expense'].id, 'product_id': self.product_a.id, 'currency_id': self.company_data['currency'].id, 'tax_line_id': False, 'analytic_distribution': {str(self.analytic_account_1.id): 100}, }, ]) # Check expense analytic lines. self.assertRecordValues(expense_sheet.account_move_id.line_ids.analytic_line_ids.sorted('amount'), [ { 'amount': -869.57, 'date': fields.Date.from_string('2016-01-01'), 'account_id': self.analytic_account_1.id, 'currency_id': self.company_data['currency'].id, }, { 'amount': -434.78, 'date': fields.Date.from_string('2016-01-01'), 'account_id': self.analytic_account_2.id, 'currency_id': self.company_data['currency'].id, }, ]) def test_expense_company_account(self): """ Create an expense with payment mode 'Company' and post it (it should not fail) """ with Form(self.env['hr.expense']) as expense_form: expense_form.name = 'Company expense' expense_form.date = '2022-11-17' expense_form.total_amount = 1000.0 expense_form.payment_mode = 'company_account' expense_form.employee_id = self.expense_employee expense_form.product_id = self.product_a expense = expense_form.save() with Form(self.env['hr.expense.sheet']) as expense_sheet_form: # Use same values that will be used by action_submit_expenses expense_sheet_form.employee_id = expense.employee_id expense_sheet_form.name = expense.name expense_sheet_form.expense_line_ids.add(expense) expense_sheet = expense_sheet_form.save() expense_sheet.action_submit_sheet() expense_sheet.approve_expense_sheets() expense_sheet.action_sheet_move_create() def test_account_entry_multi_currency(self): """ Checking accounting move entries and analytic entries when submitting expense. With multi-currency. And taxes. """ expense = self.env['hr.expense.sheet'].create({ 'name': 'Expense for Dick Tracy', 'employee_id': self.expense_employee.id, }) tax = self.env['account.tax'].create({ 'name': 'Tax Expense 10%', 'amount': 10, 'amount_type': 'percent', 'type_tax_use': 'purchase', 'price_include': True, }) self.env['hr.expense'].create({ 'name': 'Choucroute Saucisse', 'employee_id': self.expense_employee.id, 'product_id': self.product_c.id, 'total_amount': 700.0, 'tax_ids': [(6, 0, tax.ids)], 'sheet_id': expense.id, 'analytic_distribution': {self.analytic_account_1.id: 100}, 'currency_id': self.currency_data['currency'].id, # rate is 1:2 }) # State should default to draft self.assertEqual(expense.state, 'draft', 'Expense should be created in Draft state') # Submitted to Manager expense.action_submit_sheet() self.assertEqual(expense.state, 'submit', 'Expense is not in Reported state') # Approve expense.approve_expense_sheets() self.assertEqual(expense.state, 'approve', 'Expense is not in Approved state') # Create Expense Entries expense.action_sheet_move_create() self.assertEqual(expense.state, 'post', 'Expense is not in Waiting Payment state') # Should get this result [(0.0, 350.0, -700.0), (318.18, 0.0, 636.36), (31.82, 0.0, 63.64)] analytic_line = expense.account_move_id.line_ids.analytic_line_ids self.assertEqual(len(analytic_line), 1) # Expenses paid by the employee are always translated in company currency self.assertInvoiceValues(expense.account_move_id, [ { 'balance': 318.18, # 700 * 1:2 (rate) / 1.1 (incl. tax) 'amount_currency': 318.18, 'product_id': self.product_c.id, 'price_unit': 350.0, 'price_subtotal': 318.18, 'price_total': 350.0, 'analytic_line_ids': analytic_line.ids, }, { 'balance': 31.82, 'amount_currency': 31.82, 'product_id': False, 'price_unit': 0.0, 'price_subtotal': 0.0, 'price_total': 0.0, 'analytic_line_ids': [], }, { 'balance': -350.0, 'amount_currency': -350.0, 'product_id': False, 'price_unit': 0.0, 'price_subtotal': 0.0, 'price_total': 0.0, 'analytic_line_ids': [], }, ], { 'amount_total': 350.0, }) def test_account_entry_multi_currency_company_account(self): """ Checking accounting payment entry when payment_mode is 'Company'. With multi-currency.""" expense = self.env['hr.expense'].create({ 'name': 'Company expense', 'date': '2022-11-17', 'total_amount': 1000.0, 'payment_mode': 'company_account', 'employee_id': self.expense_employee.id, 'product_id': self.product_c.id, 'currency_id': self.currency_data['currency'].id, # rate is 1:2 }) foreign_bank_journal = self.company_data['default_journal_bank'].copy() foreign_bank_journal.currency_id = self.currency_data['currency'].id foreign_bank_journal_account = foreign_bank_journal.default_account_id.copy() foreign_bank_journal_account.currency_id = self.currency_data['currency'].id foreign_bank_journal.default_account_id = foreign_bank_journal_account.id expense_sheet = self.env['hr.expense.sheet'].create({ 'name': "test_account_entry_multi_currency_own_account", 'employee_id': self.expense_employee.id, 'accounting_date': '2020-01-01', 'bank_journal_id': foreign_bank_journal.id, 'expense_line_ids': [Command.set(expense.ids)], }) expense_sheet.action_submit_sheet() expense_sheet.approve_expense_sheets() expense_sheet.action_sheet_move_create() self.assertRecordValues(expense_sheet.account_move_id.payment_id, [{ 'currency_id': self.currency_data['currency'].id, }]) self.assertRecordValues(expense_sheet.account_move_id.line_ids, [ {'currency_id': self.currency_data['currency'].id}, {'currency_id': self.currency_data['currency'].id}, {'currency_id': self.currency_data['currency'].id}, {'currency_id': self.currency_data['currency'].id}, ]) def test_account_entry_mixed_multi_currency_company_account(self): """ Checking accounting payment entry when payment_mode is 'Company'. With multi-currency. When several different currencies are found in the expense. """ expenses = self.env['hr.expense'].create([{ 'name': 'Company expense foreign currency', 'date': '2022-11-17', 'total_amount': 1000.0, 'payment_mode': 'company_account', 'employee_id': self.expense_employee.id, 'product_id': self.product_c.id, 'currency_id': self.currency_data['currency'].id, # rate is 1:2 }, { 'name': 'Company expense local currency', 'date': '2022-11-15', 'total_amount': 1000.0, 'payment_mode': 'company_account', 'employee_id': self.expense_employee.id, 'product_id': self.product_c.id, 'currency_id': self.company_data['currency'].id, }]) foreign_bank_journal = self.company_data['default_journal_bank'].copy() foreign_bank_journal.currency_id = self.currency_data['currency'].id foreign_bank_journal_account = foreign_bank_journal.default_account_id.copy() foreign_bank_journal_account.currency_id = self.currency_data['currency'].id foreign_bank_journal.default_account_id = foreign_bank_journal_account.id expense_sheet = self.env['hr.expense.sheet'].create({ 'name': "test_account_entry_multi_currency_own_account", 'employee_id': self.expense_employee.id, 'accounting_date': '2020-01-01', 'bank_journal_id': foreign_bank_journal.id, 'expense_line_ids': [Command.set(expenses.ids)], }) expense_sheet.action_submit_sheet() expense_sheet.approve_expense_sheets() expense_sheet.action_sheet_move_create() self.assertRecordValues(expense_sheet.account_move_id.payment_id, [{ 'currency_id': self.company_data['currency'].id, # Should override to company currency }]) self.assertRecordValues(expense_sheet.account_move_id.line_ids, [ {'currency_id': self.company_data['currency'].id}, # Should override to company currency {'currency_id': self.company_data['currency'].id}, # Should override to company currency {'currency_id': self.company_data['currency'].id}, # Should override to company currency {'currency_id': self.company_data['currency'].id}, # Should override to company currency {'currency_id': self.company_data['currency'].id}, # Should override to company currency {'currency_id': self.company_data['currency'].id}, # Should override to company currency {'currency_id': self.company_data['currency'].id}, # Should override to company currency ]) def test_account_entry_multi_currency_own_account(self): """ Checking accounting payment entry when payment_mode is 'Company'. With multi-currency.""" expense = self.env['hr.expense'].create({ 'name': 'Company expense', 'date': '2022-11-17', 'payment_mode': 'own_account', 'employee_id': self.expense_employee.id, 'product_id': self.product_a.id, 'currency_id': self.currency_data['currency'].id, # rate is 1:2 }) foreign_sale_journal = self.company_data['default_journal_sale'].copy() foreign_sale_journal.currency_id = self.currency_data['currency'].id expense_sheet = self.env['hr.expense.sheet'].create({ 'name': "test_account_entry_multi_currency_own_account", 'employee_id': self.expense_employee.id, 'accounting_date': '2020-01-01', 'journal_id': foreign_sale_journal.id, 'expense_line_ids': [Command.set(expense.ids)], }) expense_sheet.action_submit_sheet() expense_sheet.approve_expense_sheets() expense_sheet.action_sheet_move_create() self.assertRecordValues(expense_sheet.account_move_id, [{ 'currency_id': expense_sheet.company_id.currency_id.id, }]) self.assertRecordValues(expense_sheet.account_move_id.line_ids, [ {'currency_id': expense_sheet.company_id.currency_id.id}, {'currency_id': expense_sheet.company_id.currency_id.id}, {'currency_id': expense_sheet.company_id.currency_id.id}, ]) def test_multicurrencies_rounding_consistency(self): # pylint: disable=bad-whitespace foreign_currency = self.env['res.currency'].create({ 'name': 'Exposure', 'symbol': ' ', 'rounding': 0.01, 'position': 'after', 'currency_unit_label': 'Nothing', 'currency_subunit_label': 'Smaller Nothing', }) self.env['res.currency.rate'].create({ 'name': '2016-01-01', 'rate': 1/0.148431, 'currency_id': foreign_currency.id, 'company_id': self.company_data['company'].id, }) foreign_sale_journal = self.company_data['default_journal_sale'].copy() foreign_sale_journal.currency_id = foreign_currency.id tax = self.env['account.tax'].create({ 'name': 'Tax Expense 15%', 'amount': 15, 'amount_type': 'percent', 'type_tax_use': 'purchase', 'price_include': True, }) taxes = tax + tax.copy() expense_sheet_own_1_tax = self.env['hr.expense.sheet'].create({ 'name': "own expense 1 tax", 'employee_id': self.expense_employee.id, 'accounting_date': '2020-01-01', 'journal_id': foreign_sale_journal.id, 'expense_line_ids': [Command.create({ 'name': 'Own expense', 'date': '2022-11-16', 'payment_mode': 'own_account', 'total_amount': 100, 'employee_id': self.expense_employee.id, 'product_id': self.product_c.id, 'currency_id': foreign_currency.id, # rate is 1:0.148431 'tax_ids': [Command.set(tax.ids)], })], }) expense_sheet_own_2_tax = self.env['hr.expense.sheet'].create({ 'name': "own expense 2 taxes", 'employee_id': self.expense_employee.id, 'accounting_date': '2020-01-01', 'journal_id': foreign_sale_journal.id, 'expense_line_ids': [Command.create({ 'name': 'Own expense', 'date': '2022-11-17', 'payment_mode': 'own_account', 'total_amount': 100, 'employee_id': self.expense_employee.id, 'product_id': self.product_c.id, 'currency_id': foreign_currency.id, # rate is 1:0.148431 'tax_ids': [Command.set(taxes.ids)], })], }) expense_sheet_company_1_tax = self.env['hr.expense.sheet'].create({ 'name': "company expense 1 taxes", 'employee_id': self.expense_employee.id, 'accounting_date': '2020-01-01', 'journal_id': foreign_sale_journal.id, 'expense_line_ids': [Command.create({ 'name': 'Company expense', 'date': '2022-11-18', 'payment_mode': 'company_account', 'total_amount': 100, 'employee_id': self.expense_employee.id, 'product_id': self.product_c.id, 'currency_id': foreign_currency.id, # rate is 1:0.148431 'tax_ids': [Command.set(tax.ids)], })], }) expense_sheet_company_2_tax = self.env['hr.expense.sheet'].create({ 'name': "company expense 2 taxes", 'employee_id': self.expense_employee.id, 'accounting_date': '2020-01-01', 'journal_id': foreign_sale_journal.id, 'expense_line_ids': [Command.create({ 'name': 'Company expense', 'date': '2022-11-19', 'payment_mode': 'company_account', 'total_amount': 100, 'employee_id': self.expense_employee.id, 'product_id': self.product_c.id, 'currency_id': foreign_currency.id, # rate is 1:0.148431 'tax_ids': [Command.set(taxes.ids)], })], }) sheets = expense_sheet_own_1_tax + expense_sheet_own_2_tax + expense_sheet_company_1_tax + expense_sheet_company_2_tax self.assertRecordValues(sheets.expense_line_ids, [ {'untaxed_amount': 86.96, 'total_amount': 100.00, 'total_amount_company': 14.84, 'amount_tax': 13.04, 'amount_tax_company': 1.94}, {'untaxed_amount': 76.92, 'total_amount': 100.00, 'total_amount_company': 14.84, 'amount_tax': 23.08, 'amount_tax_company': 3.42}, {'untaxed_amount': 86.96, 'total_amount': 100.00, 'total_amount_company': 14.84, 'amount_tax': 13.04, 'amount_tax_company': 1.94}, {'untaxed_amount': 76.92, 'total_amount': 100.00, 'total_amount_company': 14.84, 'amount_tax': 23.08, 'amount_tax_company': 3.42}, ]) sheets.action_submit_sheet() sheets.approve_expense_sheets() sheets.action_sheet_move_create() self.assertRecordValues(expense_sheet_own_1_tax.account_move_id.line_ids, [ {'balance': 12.90, 'amount_currency': 12.90, 'currency_id': self.company_data['currency'].id}, {'balance': 1.94, 'amount_currency': 1.94, 'currency_id': self.company_data['currency'].id}, {'balance': -14.84, 'amount_currency': -14.84, 'currency_id': self.company_data['currency'].id}, ]) self.assertRecordValues(expense_sheet_own_2_tax.account_move_id.line_ids, [ {'balance': 11.42, 'amount_currency': 11.42, 'currency_id': self.company_data['currency'].id}, {'balance': 1.71, 'amount_currency': 1.71, 'currency_id': self.company_data['currency'].id}, {'balance': 1.71, 'amount_currency': 1.71, 'currency_id': self.company_data['currency'].id}, # == 3.42 amount_tax_company {'balance': -14.84, 'amount_currency': -14.84, 'currency_id': self.company_data['currency'].id}, ]) self.assertRecordValues(expense_sheet_company_1_tax.account_move_id.line_ids, [ {'balance': 12.90, 'amount_currency': 86.96, 'currency_id': foreign_currency.id}, {'balance': 1.94, 'amount_currency': 13.04, 'currency_id': foreign_currency.id}, {'balance': -14.84, 'amount_currency': -100.00, 'currency_id': foreign_currency.id}, ]) self.assertRecordValues(expense_sheet_company_2_tax.account_move_id.line_ids, [ {'balance': 11.42, 'amount_currency': 76.92, 'currency_id': foreign_currency.id}, {'balance': 1.71, 'amount_currency': 11.54, 'currency_id': foreign_currency.id}, # == 3.42 amount_tax_company & 23.08 amount_tax {'balance': 1.71, 'amount_currency': 11.54, 'currency_id': foreign_currency.id}, # One cent more in currency due to rounding {'balance': -14.84, 'amount_currency': -100.00, 'currency_id': foreign_currency.id}, ]) def test_expenses_with_tax_and_lockdate(self): ''' Test creating a journal entry for multiple expenses using taxes. A lock date is set in order to trigger the recomputation of the taxes base amount. ''' self.env.company.tax_lock_date = '2020-02-01' expense = self.env['hr.expense.sheet'].create({ 'name': 'Expense for John Smith', 'employee_id': self.expense_employee.id, 'accounting_date': '2020-01-01' }) for i in range(2): expense_line = self.env['hr.expense'].create({ 'name': 'Car Travel Expenses', 'employee_id': self.expense_employee.id, 'product_id': self.product_a.id, 'unit_amount': 350.00, 'tax_ids': [(6, 0, [self.tax_purchase_a.id])], 'sheet_id': expense.id, 'analytic_distribution': {str(self.analytic_account_1.id): 100}, }) expense.action_submit_sheet() expense.approve_expense_sheets() # Assert not "Cannot create unbalanced journal entry" error. expense.action_sheet_move_create() def test_reconcile_payment(self): tax = self.env['account.tax'].create({ 'name': 'tax abc', 'type_tax_use': 'purchase', 'amount_type': 'percent', 'amount': 15, 'price_include': False, 'include_base_amount': False, 'tax_exigibility': 'on_payment' }) company = self.env.company.id tax.cash_basis_transition_account_id = self.env['account.account'].create({ 'name': "test", 'code': 999991, 'reconcile': True, 'account_type': 'asset_current', 'company_id': company, }).id sheet = self.env['hr.expense.sheet'].create({ 'company_id': company, 'employee_id': self.expense_employee.id, 'name': 'test sheet', 'expense_line_ids': [ (0, 0, { 'name': 'expense_1', 'date': '2016-01-01', 'product_id': self.product_a.id, 'unit_amount': 10.0, 'employee_id': self.expense_employee.id, 'tax_ids': tax }), (0, 0, { 'name': 'expense_2', 'date': '2016-01-01', 'product_id': self.product_a.id, 'unit_amount': 1.0, 'employee_id': self.expense_employee.id, 'tax_ids': tax }), ], }) #actions sheet.action_submit_sheet() sheet.approve_expense_sheets() sheet.action_sheet_move_create() action_data = sheet.action_register_payment() wizard = Form(self.env['account.payment.register'].with_context(action_data['context'])).save() action = wizard.action_create_payments() self.assertEqual(sheet.state, 'done', 'all account.move.line linked to expenses must be reconciled after payment') move = self.env['account.payment'].browse(action['res_id']).move_id move.button_cancel() self.assertEqual(sheet.state, 'done', 'Sheet state must not change when the payment linked to that sheet is canceled') def test_expense_amount_total_signed_compute(self): sheet = self.env['hr.expense.sheet'].create({ 'company_id': self.env.company.id, 'employee_id': self.expense_employee.id, 'name': 'test sheet', 'expense_line_ids': [ (0, 0, { 'name': 'expense_1', 'date': '2016-01-01', 'product_id': self.product_a.id, 'unit_amount': 10.0, 'employee_id': self.expense_employee.id }), ], }) #actions sheet.action_submit_sheet() sheet.approve_expense_sheets() sheet.action_sheet_move_create() action_data = sheet.action_register_payment() wizard = Form(self.env['account.payment.register'].with_context(action_data['context'])).save() action = wizard.action_create_payments() move = self.env['account.payment'].browse(action['res_id']).move_id self.assertEqual(move.amount_total_signed, 10.0, 'The total amount of the payment move is not correct') def test_form_defaults_from_product(self): """ As soon as you set a product, the expense name, uom, taxes and account are set according to the product. """ # Disable multi-uom self.env.ref('base.group_user').implied_ids -= self.env.ref('uom.group_uom') self.expense_user_employee.groups_id -= self.env.ref('uom.group_uom') # Use the expense employee Expense = self.env['hr.expense'].with_user(self.expense_user_employee) # Make sure the multi-uom is correctly disabled for the user creating the expense self.assertFalse(Expense.env.user.has_group('uom.group_uom')) # Use a product not using the default uom "Unit(s)" product = Expense.env.ref('hr_expense.expense_product_mileage') expense_form = Form(Expense) expense_form.product_id = product expense = expense_form.save() self.assertEqual(expense.name, product.display_name) self.assertEqual(expense.product_uom_id, product.uom_id) self.assertEqual(expense.tax_ids, product.supplier_taxes_id) self.assertEqual(expense.account_id, product._get_product_accounts()['expense']) def test_expense_account(self): """ Checking accounting move entries for the accounts set on the expenses """ account_expense_1 = self.env['account.account'].create({ 'code': '610010', 'name': 'Expense Account 1' }) account_expense_2 = self.env['account.account'].create({ 'code': '610020', 'name': 'Expense Account 2' }) expense_sheet = self.env['hr.expense.sheet'].create({ 'name': 'First Expense for employee', 'employee_id': self.expense_employee.id, 'journal_id': self.company_data['default_journal_purchase'].id, 'accounting_date': '2022-01-20', 'expense_line_ids': [ Command.create({ # Expense on Expense Account 1 'name': 'expense_1', 'date': '2022-01-05', 'account_id': account_expense_1.id, 'product_id': self.product_a.id, 'unit_amount': 115.0, 'employee_id': self.expense_employee.id, }), Command.create({ # Expense on Expense Account 2 'name': 'expense_2', 'date': '2022-01-08', 'account_id': account_expense_2.id, 'product_id': self.product_a.id, 'unit_amount': 230.0, 'employee_id': self.expense_employee.id, }), ], }) self.assertRecordValues(expense_sheet, [{'state': 'draft', 'total_amount': 345.0}]) expense_sheet.action_submit_sheet() expense_sheet.approve_expense_sheets() expense_sheet.action_sheet_move_create() # Check expense sheet journal entry values. self.assertRecordValues(expense_sheet.account_move_id.line_ids.sorted('balance'), [ # Receivable lines: { 'balance': -345.0, # 115 + 230 'account_id': self.company_data['default_account_payable'].id, }, # Tax lines: { 'balance': 15.0, 'account_id': self.company_data['default_account_tax_purchase'].id, }, { 'balance': 30.0, 'account_id': self.company_data['default_account_tax_purchase'].id, }, # Expense line 1: { 'balance': 100.0, # 115 / 1.15 (tax incl.) 'account_id': account_expense_1.id, }, # Expense line 2: { 'balance': 200.0, # 230 / 1.15 (tax incl.) 'account_id': account_expense_2.id, }, ]) def test_employee_supplier(self): """ Checking accounting move entries for the supplier set to the employee """ expense_sheet = self.env['hr.expense.sheet'].create({ 'name': 'First Expense for employee', 'employee_id': self.expense_employee.id, 'journal_id': self.company_data['default_journal_purchase'].id, 'accounting_date': '2022-01-20', 'expense_line_ids': [ Command.create({ # Expense on Expense Account 1 'name': 'expense_1', 'date': '2022-01-05', 'product_id': self.product_a.id, 'unit_amount': 115.0, 'employee_id': self.expense_employee.id, }), Command.create({ # Expense on Expense Account 2 'name': 'expense_2', 'date': '2022-01-08', 'product_id': self.product_a.id, 'unit_amount': 230.0, 'employee_id': self.expense_employee.id, }), ], }) expense_sheet.action_submit_sheet() expense_sheet.approve_expense_sheets() expense_sheet.action_sheet_move_create() # Check whether employee is set as supplier on the receipt self.assertRecordValues(expense_sheet.account_move_id, [{ 'partner_id': self.expense_user_employee.partner_id.id, }]) def test_print_expense_check(self): """ Test the check content when printing a check that comes from an expense """ sheet = self.env['hr.expense.sheet'].create({ 'company_id': self.env.company.id, 'employee_id': self.expense_employee.id, 'name': 'test sheet', 'expense_line_ids': [ (0, 0, { 'name': 'expense_1', 'date': '2016-01-01', 'product_id': self.product_a.id, 'unit_amount': 10.0, 'employee_id': self.expense_employee.id, }), (0, 0, { 'name': 'expense_2', 'date': '2016-01-01', 'product_id': self.product_a.id, 'unit_amount': 1.0, 'employee_id': self.expense_employee.id, }), ], }) #actions sheet.action_submit_sheet() sheet.approve_expense_sheets() sheet.action_sheet_move_create() action_data = sheet.action_register_payment() payment_method_line = self.env.company.bank_journal_ids.outbound_payment_method_line_ids.filtered(lambda m: m.code == 'check_printing') with Form(self.env[action_data['res_model']].with_context(action_data['context'])) as wiz_form: wiz_form.payment_method_line_id = payment_method_line wizard = wiz_form.save() action = wizard.action_create_payments() self.assertEqual(sheet.state, 'done', 'all account.move.line linked to expenses must be reconciled after payment') payments = self.env[action['res_model']].browse(action['res_id']) for payment in payments: pages = payment._check_get_pages() stub_line = pages[0]['stub_lines'][:1] self.assertTrue(stub_line) move = self.env[action_data['context']['active_model']].browse(action_data['context']['active_ids']) self.assertDictEqual(stub_line[0], { 'due_date': payment.date.strftime("%m/%d/%Y"), 'number': ' - '.join([move.name, move.ref] if move.ref else [move.name]), 'amount_total': formatLang(self.env, move.amount_total, currency_obj=self.env.company.currency_id), 'amount_residual': '-', 'amount_paid': formatLang(self.env, payment.amount_total, currency_obj=self.env.company.currency_id), 'currency': self.env.company.currency_id }) def test_hr_expense_split(self): """ Check Split Expense flow. """ expense = self.env['hr.expense'].create({ 'name': 'Expense To Test Split - Diego, libre dans sa tête', 'employee_id': self.expense_employee.id, 'product_id': self.product_zero_cost.id, 'total_amount': 100.00, 'tax_ids': [(6, 0, [self.tax_purchase_a.id])], 'analytic_distribution': {self.analytic_account_1.id: 100}, }) split_wizard = expense.action_split_wizard() wizard = self.env['hr.expense.split.wizard'].browse(split_wizard['res_id']) # Check default hr.expense.split values self.assertRecordValues(wizard.expense_split_line_ids, [ { 'name': expense.name, 'wizard_id': wizard.id, 'expense_id': expense.id, 'product_id': expense.product_id.id, 'tax_ids': expense.tax_ids.ids, 'total_amount': expense.total_amount / 2, 'amount_tax': 6.52, 'employee_id': expense.employee_id.id, 'company_id': expense.company_id.id, 'currency_id': expense.currency_id.id, 'analytic_distribution': expense.analytic_distribution, } for i in range(0, 2)]) self.assertEqual(wizard.split_possible, True) self.assertEqual(wizard.total_amount, expense.total_amount) # Grant Analytic Accounting rights, to be able to modify analytic_distribution from the wizard self.env.user.groups_id += self.env.ref('analytic.group_analytic_accounting') with Form(wizard) as form: form.expense_split_line_ids.remove(index=0) self.assertEqual(form.split_possible, False) # Check removing tax_ids and analytic_distribution with form.expense_split_line_ids.edit(0) as line: line.total_amount = 20 line.tax_ids.clear() line.analytic_distribution = {} self.assertEqual(line.total_amount, 20) self.assertEqual(line.amount_tax, 0) self.assertEqual(form.split_possible, False) # This line should have the same tax_ids and analytic_distribution as original expense with form.expense_split_line_ids.new() as line: line.total_amount = 30 self.assertEqual(line.total_amount, 30) self.assertEqual(line.amount_tax, 3.91) self.assertEqual(form.split_possible, False) self.assertEqual(form.total_amount, 50) # Check adding tax_ids and setting analytic_distribution with form.expense_split_line_ids.new() as line: line.total_amount = 50 line.tax_ids.add(self.tax_purchase_b) line.analytic_distribution = {self.analytic_account_2.id: 100} self.assertEqual(line.total_amount, 50) self.assertAlmostEqual(line.amount_tax, 11.54) # Check wizard values self.assertEqual(form.total_amount, 100) self.assertEqual(form.total_amount_original, 100) self.assertAlmostEqual(form.total_amount_taxes, 15.45) self.assertEqual(form.split_possible, True) wizard.action_split_expense() # Check that split resulted into expenses with correct values expenses_after_split = self.env['hr.expense'].search( [ ('name', '=', expense.name) ] ) self.assertRecordValues(expenses_after_split.sorted('total_amount'), [ { 'name': expense.name, 'employee_id': expense.employee_id.id, 'product_id': expense.product_id.id, 'total_amount': 20.0, 'tax_ids': [], 'amount_tax': 0, 'untaxed_amount': 20, 'analytic_distribution': False, }, { 'name': expense.name, 'employee_id': expense.employee_id.id, 'product_id': expense.product_id.id, 'total_amount': 30, 'tax_ids': [self.tax_purchase_a.id], 'amount_tax': 3.91, 'untaxed_amount': 26.09, 'analytic_distribution': {str(self.analytic_account_1.id): 100}, }, { 'name': expense.name, 'employee_id': expense.employee_id.id, 'product_id': expense.product_id.id, 'total_amount': 50, 'tax_ids': [self.tax_purchase_a.id, self.tax_purchase_b.id], 'amount_tax': 11.54, 'untaxed_amount': 38.46, 'analytic_distribution': {str(self.analytic_account_2.id): 100}, } ]) def test_analytic_account_deleted(self): """ Test that an analytic account cannot be deleted if it is used in an expense """ expense = self.env['hr.expense.sheet'].create({ 'name': 'Expense for Dick Tracy', 'employee_id': self.expense_employee.id, }) expense = self.env['hr.expense'].create({ 'name': 'Choucroute Saucisse', 'employee_id': self.expense_employee.id, 'product_id': self.product_a.id, 'unit_amount': 700.00, 'sheet_id': expense.id, 'analytic_distribution': { self.analytic_account_1.id: 50, self.analytic_account_2.id: 50, }, }) with self.assertRaises(UserError): (self.analytic_account_1 | self.analytic_account_2).unlink() expense.unlink() self.analytic_account_1.unlink() def test_reset_move_to_draft(self): """ Test the state of an expense and its report after resetting the paid move to draft """ expense_sheet = self.env['hr.expense.sheet'].create({ 'company_id': self.env.company.id, 'employee_id': self.expense_employee.id, 'name': 'test sheet', 'expense_line_ids': [ (0, 0, { 'name': 'expense_1', 'employee_id': self.expense_employee.id, 'product_id': self.product_a.id, 'unit_amount': 1000.00, }), ], }) expense = expense_sheet.expense_line_ids self.assertEqual(expense.state, 'draft', 'Expense state must be draft before sheet submission') self.assertEqual(expense_sheet.state, 'draft', 'Sheet state must be draft before submission') # Submit report expense_sheet.action_submit_sheet() self.assertEqual(expense.state, 'reported', 'Expense state must be reported after sheet submission') self.assertEqual(expense_sheet.state, 'submit', 'Sheet state must be submit after submission') # Approve report expense_sheet.approve_expense_sheets() self.assertEqual(expense.state, 'approved', 'Expense state must be draft after sheet approval') self.assertEqual(expense_sheet.state, 'approve', 'Sheet state must be draft after approval') # Create move expense_sheet.action_sheet_move_create() self.assertEqual(expense.state, 'approved', 'Expense state must be draft after posting move') self.assertEqual(expense_sheet.state, 'post', 'Sheet state must be draft after posting move') # Pay move move = expense_sheet.account_move_id self.env['account.payment.register'].with_context(active_model='account.move', active_ids=move.ids).create({ 'amount': 1000.0, })._create_payments() self.assertEqual(expense.state, 'done', 'Expense state must be done after payment') self.assertEqual(expense_sheet.state, 'done', 'Sheet state must be done after payment') # Reset move to draft move.button_draft() self.assertEqual(expense.state, 'approved', 'Expense state must be approved after resetting move to draft') self.assertEqual(expense_sheet.state, 'post', 'Sheet state must be done after resetting move to draft') # Post and pay move again move.action_post() self.env['account.payment.register'].with_context(active_model='account.move', active_ids=move.ids).create({ 'amount': 1000.0, })._create_payments() self.assertEqual(expense.state, 'done', 'Expense state must be done after payment') self.assertEqual(expense_sheet.state, 'done', 'Sheet state must be done after payment') def test_expense_sheet_due_date(self): """ Test expense sheet bill due date """ self.expense_employee.user_partner_id.property_supplier_payment_term_id = self.env.ref('account.account_payment_term_30days') with freeze_time('2021-01-01'): expense_sheet = self.env['hr.expense.sheet'].create({ 'name': 'Expense for John Smith', 'employee_id': self.expense_employee.id, 'expense_line_ids': [Command.create({ 'name': 'Car Travel Expenses', 'employee_id': self.expense_employee.id, 'product_id': self.product_a.id, 'unit_amount': 350.00, 'date': '2021-01-01', })] }) expense_sheet.action_submit_sheet() expense_sheet.approve_expense_sheets() expense_sheet.action_sheet_move_create() move = expense_sheet.account_move_id expected_date = fields.Date.from_string('2021-01-31') self.assertEqual(move.invoice_date_due, expected_date, 'Bill due date should follow employee payment terms') def test_inverse_total_amount(self): """ Test if the inverse method works correctly """ expense = self.env['hr.expense'].create({ 'name': 'Choucroute Saucisse', 'employee_id': self.expense_employee.id, 'product_id': self.product_c.id, 'total_amount': 60, 'unit_amount': 0, 'tax_ids': [self.tax_purchase_a.id, self.tax_purchase_b.id], 'analytic_distribution': { self.analytic_account_1.id: 50, self.analytic_account_2.id: 50, }, }) expense.total_amount = 90 self.assertEqual(expense.unit_amount, 90, 'Unit amount should be the same as total amount was written to') def test_expense_from_attachments(self): # avoid passing through extraction when installed if 'hr.expense.extract.words' in self.env: self.env.company.expense_extract_show_ocr_option_selection = 'no_send' self.env.user.employee_id = self.expense_employee.id attachment = self.env['ir.attachment'].create({ 'datas': b"R0lGODdhAQABAIAAAP///////ywAAAAAAQABAAACAkQBADs=", 'name': 'file.png', 'res_model': 'hr.expense', }) product = self.env['product.product'].search([('can_be_expensed', '=', True)]) # reproduce the same way we get the product by default if product: product = product.filtered(lambda p: p.default_code == "EXP_GEN") or product[0] product.property_account_expense_id = self.company_data['default_account_payable'] self.env['hr.expense'].create_expense_from_attachments(attachment.id) expense = self.env['hr.expense'].search([], order='id desc', limit=1) self.assertEqual(expense.account_id, product.property_account_expense_id, "The expense account should be the default one of the product") def test_expense_sheet_attachments_sync(self): """ Test that the hr.expense.sheet attachments stay in sync with the attachments associated with the expense lines Syncing should happen when: - When adding/removing expense_line_ids on a hr.expense.sheet <-> changing sheet_id on an expense - When deleting an expense that is associated with an hr.expense.sheet - When adding/removing an attachment of an expense that is associated with an hr.expense.sheet """ def assert_attachments_are_synced(sheet, attachments_on_sheet, sheet_has_attachment): if sheet_has_attachment: self.assertTrue(bool(attachments_on_sheet), "Attachment that belongs to the hr.expense.sheet only was removed unexpectedly") self.assertSetEqual( set(sheet.expense_line_ids.attachment_ids.mapped('checksum')), set((sheet.attachment_ids - attachments_on_sheet).mapped('checksum')), "Attachments between expenses and their sheet is not in sync.", ) for sheet_has_attachment in (False, True): expense_1, expense_2, expense_3 = self.env['hr.expense'].create([{ 'name': 'expense_1', 'employee_id': self.expense_employee.id, 'product_id': self.product_c.id, 'total_amount': 1000, }, { 'name': 'expense_2', 'employee_id': self.expense_employee.id, 'product_id': self.product_c.id, 'total_amount': 999, }, { 'name': 'expense_3', 'employee_id': self.expense_employee.id, 'product_id': self.product_c.id, 'total_amount': 998, }]) self.env['ir.attachment'].create([{ 'name': "test_file_1.txt", 'datas': base64.b64encode(b'content'), 'res_id': expense_1.id, 'res_model': 'hr.expense', }, { 'name': "test_file_2.txt", 'datas': base64.b64encode(b'other content'), 'res_id': expense_2.id, 'res_model': 'hr.expense', }, { 'name': "test_file_3.txt", 'datas': base64.b64encode(b'different content'), 'res_id': expense_3.id, 'res_model': 'hr.expense', }]) sheet = self.env['hr.expense.sheet'].create({ 'company_id': self.env.company.id, 'employee_id': self.expense_employee.id, 'name': 'test sheet', 'expense_line_ids': [Command.set([expense_1.id, expense_2.id, expense_3.id])], }) sheet_attachment = self.env['ir.attachment'].create({ 'name': "test_file_4.txt", 'datas': base64.b64encode(b'yet another different content'), 'res_id': sheet.id, 'res_model': 'hr.expense.sheet', }) if sheet_has_attachment else self.env['ir.attachment'] assert_attachments_are_synced(sheet, sheet_attachment, sheet_has_attachment) expense_1.attachment_ids.unlink() assert_attachments_are_synced(sheet, sheet_attachment, sheet_has_attachment) self.env['ir.attachment'].create({ 'name': "test_file_1.txt", 'datas': base64.b64encode(b'content'), 'res_id': expense_1.id, 'res_model': 'hr.expense', }) assert_attachments_are_synced(sheet, sheet_attachment, sheet_has_attachment) expense_2.sheet_id = False assert_attachments_are_synced(sheet, sheet_attachment, sheet_has_attachment) expense_2.sheet_id = sheet assert_attachments_are_synced(sheet, sheet_attachment, sheet_has_attachment) sheet.expense_line_ids = [Command.set([expense_1.id, expense_3.id])] assert_attachments_are_synced(sheet, sheet_attachment, sheet_has_attachment) expense_3.unlink() assert_attachments_are_synced(sheet, sheet_attachment, sheet_has_attachment) sheet.attachment_ids.filtered( lambda att: att.checksum in sheet.expense_line_ids.attachment_ids.mapped('checksum') ).unlink() assert_attachments_are_synced(sheet, sheet_attachment, sheet_has_attachment) def test_create_report_name(self): """ When an expense sheet is created from one or more expense, the report name is generated through the expense name or date. As the expense sheet is created directly from the hr.expense._get_default_expense_sheet_values method, we only need to test the method. """ expense_with_date_1, expense_with_date_2, expense_without_date = self.env['hr.expense'].create([{ 'company_id': self.company_data['company'].id, 'name': f'test expense {i}', 'employee_id': self.expense_employee.id, 'product_id': self.product_a.id, 'unit_amount': self.product_a.standard_price, 'date': '2021-01-01', 'quantity': i + 1, } for i in range(3)]) expense_without_date.date = False # CASE 1: only one expense with or without date -> expense name sheet_name = expense_with_date_1._get_default_expense_sheet_values()[0]['name'] self.assertEqual(expense_with_date_1.name, sheet_name, "The report name should be the same as the expense name") sheet_name = expense_without_date._get_default_expense_sheet_values()[0]['name'] self.assertEqual(expense_without_date.name, sheet_name, "The report name should be the same as the expense name") # CASE 2: two expenses with the same date -> expense date expenses = expense_with_date_1 | expense_with_date_2 sheet_name = expenses._get_default_expense_sheet_values()[0]['name'] self.assertEqual(format_date(self.env, expense_with_date_1.date), sheet_name, "The report name should be the same as the expense date") # CASE 3: two expenses with different dates -> date range expense_with_date_2.date = '2021-01-02' sheet_name = expenses._get_default_expense_sheet_values()[0]['name'] self.assertEqual( f"{format_date(self.env, expense_with_date_1.date)} - {format_date(self.env, expense_with_date_2.date)}", sheet_name, "The report name should be the date range of the expenses", ) # CASE 4: One or more expense doesn't have a date (single sheet) -> No fallback name expenses |= expense_without_date sheet_name = expenses._get_default_expense_sheet_values()[0]['name'] self.assertFalse( sheet_name, "The report (with the empty expense date) name should be empty as a fallback when several reports are created", ) expenses.date = False sheet_name = expenses._get_default_expense_sheet_values()[0]['name'] self.assertFalse(sheet_name, "The report name should be empty as a fallback") # CASE 5: One or more expense doesn't have a date (multiple sheets) -> Fallback name expenses |= self.env['hr.expense'].create([{ 'company_id': self.company_data['company'].id, 'name': f'test expense by company {i}', 'employee_id': self.expense_employee.id, 'product_id': self.product_a.id, 'unit_amount': self.product_a.standard_price, 'payment_mode': 'company_account', 'date': '2021-01-01', 'quantity': i + 1, } for i in range(3)]) sheet_names = [sheet['name'] for sheet in expenses._get_default_expense_sheet_values()] self.assertSequenceEqual( ("New Expense Report, paid by employee", format_date(self.env, expenses[-1].date)), sheet_names, "The report name should be 'New Expense Report, paid by (employee|company)' as a fallback", ) def test_expense_product_update(self): """ Test that the expense line is correctly updated or not when its product price is updated.""" #pylint: disable=bad-whitespace product = self.env['product.product'].create({ 'name': 'product', 'uom_id': self.env.ref('uom.product_uom_unit').id, 'lst_price': 100.0, 'standard_price': 0.0, 'property_account_income_id': self.company_data['default_account_revenue'].id, 'property_account_expense_id': self.company_data['default_account_expense'].id, 'supplier_taxes_id': False, }) sheet_no_update, sheet_update = sheets = self.env['hr.expense.sheet'].create([{ 'company_id': self.env.company.id, 'employee_id': self.expense_employee.id, 'name': name, 'expense_line_ids': [ Command.create({ 'name': name, 'date': '2016-01-01', 'product_id': product.id, 'total_amount': 100.0, 'employee_id': self.expense_employee.id }), ], } for name in ('test sheet no update', 'test sheet update')]) sheet_no_update.action_submit_sheet() # No update when sheet is submitted self.assertRecordValues(sheets.expense_line_ids.sorted('name'), [ {'name': 'test sheet no update', 'unit_amount': 100.0, 'quantity': 1, 'total_amount': 100.0}, {'name': 'test sheet update', 'unit_amount': 100.0, 'quantity': 1, 'total_amount': 100.0}, ]) product.standard_price = 50.0 self.assertRecordValues(sheets.expense_line_ids.sorted('name'), [ {'name': 'test sheet no update', 'unit_amount': 100.0, 'quantity': 1, 'total_amount': 100.0}, {'name': 'test sheet update', 'unit_amount': 50.0, 'quantity': 1, 'total_amount': 50.0}, # unit_amount is updated ]) sheet_update.expense_line_ids.quantity = 5 self.assertRecordValues(sheets.expense_line_ids.sorted('name'), [ {'name': 'test sheet no update', 'unit_amount': 100.0, 'quantity': 1, 'total_amount': 100.0}, {'name': 'test sheet update', 'unit_amount': 50.0, 'quantity': 5, 'total_amount': 250.0}, # quantity & total are updated ]) product.standard_price = 0.0 self.assertRecordValues(sheets.expense_line_ids.sorted('name'), [ {'name': 'test sheet no update', 'unit_amount': 100.0, 'quantity': 1, 'total_amount': 100.0}, {'name': 'test sheet update', 'unit_amount': 250.0, 'quantity': 1, 'total_amount': 250.0}, # quantity & unit_amount only are updated ]) sheet_update.action_submit_sheet() # This sheet should not be updated any more product.standard_price = 300.0 self.assertRecordValues(sheets.expense_line_ids.sorted('name'), [ {'name': 'test sheet no update', 'unit_amount': 100.0, 'quantity': 1, 'total_amount': 100.0}, {'name': 'test sheet update', 'unit_amount': 250.0, 'quantity': 1, 'total_amount': 250.0}, # no update ]) def test_expense_mandatory_analytic_plan_product_category(self): """ Check that when an analytic plan has a mandatory applicability matching product category this is correctly triggered """ self.env['account.analytic.applicability'].create({ 'business_domain': 'expense', 'analytic_plan_id': self.analytic_plan.id, 'applicability': 'mandatory', 'product_categ_id': self.product_a.categ_id.id, }) expense_sheet = self.env['hr.expense.sheet'].create({ 'name': 'Expense for John Smith', 'employee_id': self.expense_employee.id, 'accounting_date': '2021-01-01', 'expense_line_ids': [Command.create({ 'name': 'Car Travel Expenses', 'employee_id': self.expense_employee.id, 'product_id': self.product_a.id, 'unit_amount': 350.00, 'payment_mode': 'company_account', })] }) expense_sheet.action_submit_sheet() with self.assertRaises(ValidationError, msg="One or more lines require a 100% analytic distribution."): expense_sheet.with_context(validate_analytic=True).approve_expense_sheets() expense_sheet.expense_line_ids.analytic_distribution = {self.analytic_account_1.id: 100.00} expense_sheet.with_context(validate_analytic=True).approve_expense_sheets() def test_expense_no_stealing_from_employees(self): """ Test to check that the company doesn't steal their employee when the commercial_partner_id of the employee partner is the company """ self.expense_employee.user_partner_id.parent_id = self.env.company.partner_id self.assertEqual(self.env.company.partner_id, self.expense_employee.user_partner_id.commercial_partner_id) expense_sheet = self.env['hr.expense.sheet'].create({ 'name': 'Company Cash Basis Expense Report', 'employee_id': self.expense_employee.id, 'payment_mode': 'own_account', 'state': 'approve', 'expense_line_ids': [Command.create({ 'name': 'Company Cash Basis Expense', 'product_id': self.product_c.id, 'payment_mode': 'own_account', 'total_amount': 20.0, 'employee_id': self.expense_employee.id, })] }) expense_sheet.action_submit_sheet() expense_sheet.approve_expense_sheets() expense_sheet.action_sheet_move_create() move = expense_sheet.account_move_id self.assertNotEqual(move.commercial_partner_id, self.env.company.partner_id) self.assertEqual(move.partner_id, self.expense_employee.user_partner_id) self.assertEqual(move.commercial_partner_id, self.expense_employee.user_partner_id) def test_expense_bank_account_of_employee_on_entry_and_register_payment(self): """ Test that the bank account defined on the employee form is correctly set on the entry and on the register payment when having multiple bank accounts defined on the partner """ self.partner_bank_account_1 = self.env['res.partner.bank'].create({ 'acc_number': "987654321", 'partner_id': self.expense_employee.user_partner_id.id, 'acc_type': 'bank', }) self.partner_bank_account_2 = self.env['res.partner.bank'].create({ 'acc_number': "123456789", 'partner_id': self.expense_employee.user_partner_id.id, 'acc_type': 'bank', }) # Set the second bank account for the employee self.expense_employee.bank_account_id = self.partner_bank_account_2 expense_sheet = self.env['hr.expense.sheet'].create({ 'name': 'Expense for John Smith', 'employee_id': self.expense_employee.id, 'payment_mode': 'own_account', 'state': 'approve', 'expense_line_ids': [Command.create({ 'name': 'Car Travel Expenses', 'employee_id': self.expense_employee.id, 'product_id': self.product_a.id, 'payment_mode': 'own_account', 'unit_amount': 350.00, })] }) expense_sheet.action_submit_sheet() expense_sheet.approve_expense_sheets() expense_sheet.action_sheet_move_create() move_bank_acc = expense_sheet.account_move_id.partner_bank_id self.assertEqual(move_bank_acc, self.partner_bank_account_2) action_data = expense_sheet.action_register_payment() with Form(self.env['account.payment.register'].with_context(action_data['context'])) as pay_form: self.assertEqual(pay_form.partner_bank_id, self.partner_bank_account_2) def test_expense_by_company_with_caba_tax(self): """When using cash basis tax in an expense paid by the company, the transition account should not be used.""" caba_tag = self.env['account.account.tag'].create({ 'name': 'Cash Basis Tag Final Account', 'applicability': 'taxes', }) caba_transition_account = self.env['account.account'].create({ 'name': 'Cash Basis Tax Transition Account', 'account_type': 'asset_current', 'code': '131001', }) caba_tax = self.env['account.tax'].create({ 'name': 'Cash Basis Tax', 'tax_exigibility': 'on_payment', 'amount': 15, 'cash_basis_transition_account_id': caba_transition_account.id, 'invoice_repartition_line_ids': [ Command.create({ 'factor_percent': 100, 'repartition_type': 'base', }), Command.create({ 'factor_percent': 100, 'repartition_type': 'tax', 'tag_ids': caba_tag.ids, }), ] }) expense_sheet = self.env['hr.expense.sheet'].create({ 'name': 'Company Cash Basis Expense Report', 'employee_id': self.expense_employee.id, 'payment_mode': 'company_account', 'state': 'approve', 'expense_line_ids': [Command.create({ 'name': 'Company Cash Basis Expense', 'product_id': self.product_c.id, 'payment_mode': 'company_account', 'total_amount': 20.0, 'employee_id': self.expense_employee.id, 'tax_ids': [Command.set(caba_tax.ids)], })] }) moves = expense_sheet.action_sheet_move_create() tax_lines = moves.line_ids.filtered(lambda line: line.tax_line_id == caba_tax) self.assertNotEqual(tax_lines.account_id, caba_transition_account, "The tax should not be on the transition account") self.assertEqual(tax_lines.tax_tag_ids, caba_tag, "The tax should still retrieve its tags") def test_expense_set_total_amount_to_0(self): """Checks that amount fields are correctly updating when setting total_amount to 0""" expense = self.env['hr.expense'].create({ 'name': 'Expense with amount', 'employee_id': self.expense_employee.id, 'product_id': self.product_c.id, 'total_amount': 100.0, 'tax_ids': self.tax_purchase_a.ids, }) expense.total_amount = 0.0 self.assertTrue(expense.currency_id.is_zero(expense.amount_tax)) self.assertTrue(expense.company_currency_id.is_zero(expense.total_amount_company)) def test_expense_set_quantity_to_0(self): """Checks that amount fields except for unit_amount are correctly updating when setting quantity to 0""" expense = self.env['hr.expense'].create({ 'name': 'Expense with amount', 'employee_id': self.expense_employee.id, 'product_id': self.product_b.id, 'quantity': 10 }) expense.quantity = 0 self.assertTrue(expense.currency_id.is_zero(expense.total_amount)) self.assertEqual(expense.company_currency_id.compare_amounts(expense.unit_amount, self.product_b.standard_price), 0)